{"version":3,"file":"/pc/all/libs/knockout-repeat-2.1.0.js.map","sources":["/pc/all/libs/knockout-repeat-2.1.0.js"],"sourcesContent":["// REPEAT binding for Knockout http://knockoutjs.com/\n// (c) Michael Best\n// License: MIT (http://www.opensource.org/licenses/mit-license.php)\n// Version 2.1.0\n//add by robin, fix IE8 containerLess select control foreach\n\n(function(factory) {\n    if (typeof define === 'function' && define.amd) {\n        // [1] AMD anonymous module\n        define(['knockout'], factory);\n    } else if (typeof exports === 'object') {\n        // [2] commonJS\n        factory(require('knockout'));\n    } else {\n        // [3] No module loader (plain <script> tag) - put directly in global namespace\n        factory(window.ko);\n    }\n})(function(ko) {\n\n    if (!ko.virtualElements)\n        throw Error('Repeat requires at least Knockout 2.1');\n\n    var ko_bindingFlags = ko.bindingFlags || {};\n    var ko_unwrap = ko.utils.unwrapObservable;\n\n    var koProtoName = '__ko_proto__';\n\n    if (ko.version >= \"3.0.0\") {\n        // In Knockout 3.0.0, use the node preprocessor to replace a node with a repeat binding with a virtual element\n        var provider = ko.bindingProvider.instance, previousPreprocessFn = provider.preprocessNode;\n        provider.preprocessNode = function(node) {\n            var newNodes, nodeBinding;\n            if (!previousPreprocessFn || !(newNodes = previousPreprocessFn.call(this, node))) {\n                if (node.nodeType === 1 && (nodeBinding = node.getAttribute('data-bind'))) {\n                    if (/^\\s*repeat\\s*:/.test(nodeBinding)) {\n                        var leadingComment = node.ownerDocument.createComment('ko ' + nodeBinding),\n                            trailingComment = node.ownerDocument.createComment('/ko');\n                        node.parentNode.insertBefore(leadingComment, node);\n                        node.parentNode.insertBefore(trailingComment, node.nextSibling);\n                        node.removeAttribute('data-bind');\n                        newNodes = [leadingComment, node, trailingComment];\n                    }\n                }\n            }\n            return newNodes;\n        };\n    }\n\n    ko.virtualElements.allowedBindings.repeat = true;\n    ko.bindingHandlers.repeat = {\n        flags: ko_bindingFlags.contentBind | ko_bindingFlags.canUseVirtual,\n        init: function(element, valueAccessor, allBindingsAccessor, xxx, bindingContext) {\n\n            // Read and set fixed options--these options cannot be changed\n            var repeatParam = ko_unwrap(valueAccessor());\n            if (repeatParam && typeof repeatParam == 'object' && !('length' in repeatParam)) {\n                var repeatIndex = repeatParam.index,\n                    repeatData = repeatParam.item,\n                    repeatStep = repeatParam.step,\n                    repeatReversed = repeatParam.reverse,\n                    repeatBind = repeatParam.bind,\n                    repeatInit = repeatParam.init,\n                    repeatUpdate = repeatParam.update;\n            }\n            // Set default values for options that need it\n            repeatIndex = repeatIndex || '$index';\n            repeatData = repeatData || ko.bindingHandlers.repeat.itemName || '$item';\n            repeatStep = repeatStep || 1;\n            repeatReversed = repeatReversed || false;\n\n            var parent = element.parentNode, placeholder;\n            if (element.nodeType == 8) {    // virtual element\n                // Extract the \"children\" and find the single element node\n                var childNodes = ko.utils.arrayFilter(ko.virtualElements.childNodes(element), function(node) { return node.nodeType == 1;});\n                if (childNodes.length !== 1) {\n                    throw Error(\"Repeat binding requires a single element to repeat\");\n                }\n                ko.virtualElements.emptyNode(element);\n\n                // The placeholder is the closing comment normally, or the opening comment if reversed\n                placeholder = repeatReversed ? element : element.nextSibling;\n                // The element to repeat is the contained element\n                element = childNodes[0];\n            } else {    // regular element\n                // First clean the element node and remove node's binding\n                var origBindString = element.getAttribute('data-bind');\n                ko.cleanNode(element);\n                element.removeAttribute('data-bind');\n\n                // Original element is no longer needed: delete it and create a placeholder comment\n                placeholder = element.ownerDocument.createComment('ko_repeatplaceholder ' + origBindString);\n                parent.replaceChild(placeholder, element);\n            }\n\n            // extract and remove a data-repeat-bind attribute, if present\n            if (!repeatBind) {\n                repeatBind = element.getAttribute('data-repeat-bind');\n                if (repeatBind) {\n                    element.removeAttribute('data-repeat-bind');\n                }\n            }\n\n            // Make a copy of the element node to be copied for each repetition\n            var cleanNode = element.cloneNode(true);\n            if (typeof repeatBind == \"string\") {\n                cleanNode.setAttribute('data-bind', repeatBind);\n                repeatBind = null;\n            }\n\n            // Set up persistent data\n            var lastRepeatCount = 0,\n                notificationObservable = ko.observable(),\n                repeatArray, arrayObservable;\n\n            if (repeatInit) {\n                repeatInit(parent);\n            }\n\n            var subscribable = ko.computed(function() {\n                function makeArrayItemAccessor(index) {\n                    var f = function(newValue) {\n                        var item = repeatArray[index];\n                        // Reading the value of the item\n                        if (!arguments.length) {\n                            notificationObservable();   // for dependency tracking\n                            return ko_unwrap(item);\n                        }\n                        // Writing a value to the item\n                        if (ko.isObservable(item)) {\n                            item(newValue);\n                        } else if (arrayObservable && arrayObservable.splice) {\n                            arrayObservable.splice(index, 1, newValue);\n                        } else {\n                            repeatArray[index] = newValue;\n                        }\n                        return this;\n                    };\n                    // Pretend that our accessor function is an observable\n                    f[koProtoName] = ko.observable;\n                    return f;\n                }\n\n                function makeBinding(item, index, context) {\n                    return repeatArray\n                        ? function() { return repeatBind.call(bindingContext.$data, item, index, context); }\n                        : function() { return repeatBind.call(bindingContext.$data, index, context); }\n                }\n\n                // Read and set up variable options--these options can change and will update the binding\n                var paramObservable = valueAccessor(), repeatParam = ko_unwrap(paramObservable), repeatCount = 0;\n                if (repeatParam && typeof repeatParam == 'object') {\n                    if ('length' in repeatParam) {\n                        repeatArray = repeatParam;\n                        repeatCount = repeatArray.length;\n                    } else {\n                        if ('foreach' in repeatParam) {\n                            repeatArray = ko_unwrap(paramObservable = repeatParam.foreach);\n                            if (repeatArray && typeof repeatArray == 'object' && 'length' in repeatArray) {\n                                repeatCount = repeatArray.length || 0;\n                            } else {\n                                repeatCount = repeatArray || 0;\n                                repeatArray = null;\n                            }\n                        }\n                        // If a count value is provided (>0), always output that number of items\n                        if ('count' in repeatParam)\n                            repeatCount = ko_unwrap(repeatParam.count) || repeatCount;\n                        // If a limit is provided, don't output more than the limit\n                        if ('limit' in repeatParam)\n                            repeatCount = Math.min(repeatCount, ko_unwrap(repeatParam.limit)) || repeatCount;\n                    }\n                    arrayObservable = repeatArray && ko.isObservable(paramObservable) ? paramObservable : null;\n                } else {\n                    repeatCount = repeatParam || 0;\n                }\n\n                // Remove nodes from end if array is shorter\n                for (; lastRepeatCount > repeatCount; lastRepeatCount-=repeatStep) {\n                    ko.removeNode(repeatReversed ? placeholder.nextSibling : placeholder.previousSibling);\n                }\n\n                // Notify existing nodes of change\n                notificationObservable.notifySubscribers();\n\n                // Add nodes to end if array is longer (also initially populates nodes)\n                for (; lastRepeatCount < repeatCount; lastRepeatCount+=repeatStep) {\n                    // Clone node and add to document\n                    var newNode = cleanNode.cloneNode(true);\n                    parent.insertBefore(newNode, repeatReversed ? placeholder.nextSibling : placeholder);\n                    newNode.setAttribute('data-repeat-index', lastRepeatCount);\n\n                    // Apply bindings to inserted node\n                    if (repeatArray && repeatData == '$data') {\n                        var newContext = bindingContext.createChildContext(makeArrayItemAccessor(lastRepeatCount));\n                    } else {\n                        var newContext = bindingContext.extend();\n                        if (repeatArray)\n                            newContext[repeatData] = makeArrayItemAccessor(lastRepeatCount);\n                    }\n                    newContext[repeatIndex] = lastRepeatCount;\n                    if (repeatBind) {\n                        var result = ko.applyBindingsToNode(newNode, makeBinding(newContext[repeatData], lastRepeatCount, newContext), newContext, true),\n                            shouldBindDescendants = result && result.shouldBindDescendants;\n                    }\n                    if (!repeatBind || (result && shouldBindDescendants !== false)) {\n                        ko.applyBindings(newContext, newNode);\n                    }\n                }\n                if (repeatUpdate) {\n                    repeatUpdate(parent);\n                }\n            }, null, {disposeWhenNodeIsRemoved: placeholder});\n\n            return { controlsDescendantBindings: true, subscribable: subscribable };\n        }\n    };\n});"],"names":["factory","define","amd","exports","require","window","ko","virtualElements","Error","ko_bindingFlags","bindingFlags","ko_unwrap","utils","unwrapObservable","koProtoName","version","provider","bindingProvider","instance","previousPreprocessFn","preprocessNode","node","newNodes","nodeBinding","call","this","nodeType","getAttribute","test","leadingComment","ownerDocument","createComment","trailingComment","parentNode","insertBefore","nextSibling","removeAttribute","allowedBindings","repeat","bindingHandlers","flags","contentBind","canUseVirtual","init","element","valueAccessor","allBindingsAccessor","xxx","bindingContext","repeatParam","repeatIndex","index","repeatData","item","repeatStep","step","repeatReversed","reverse","repeatBind","bind","repeatInit","repeatUpdate","update","itemName","placeholder","parent","childNodes","arrayFilter","length","emptyNode","origBindString","cleanNode","replaceChild","cloneNode","setAttribute","repeatArray","arrayObservable","lastRepeatCount","notificationObservable","observable","subscribable","computed","makeArrayItemAccessor","f","newValue","arguments","isObservable","splice","makeBinding","context","$data","paramObservable","repeatCount","foreach","count","Math","min","limit","removeNode","previousSibling","notifySubscribers","newNode","newContext","createChildContext","extend","result","applyBindingsToNode","shouldBindDescendants","applyBindings","disposeWhenNodeIsRemoved","controlsDescendantBindings"],"mappings":"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"}