devfab 1.5.0 → 2.0.0

package/lib/devfab.require.js

@@ -0,0 +1,3285 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.devfab = global.devfab || {}, global.devfab.require = {})));
+})(this, (function (exports) { 'use strict';
+
+  function _assertThisInitialized(e) {
+    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return e;
+  }
+  function _callSuper(t, o, e) {
+    return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+  }
+  function _classCallCheck(a, n) {
+    if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+  }
+  function _defineProperties(e, r) {
+    for (var t = 0; t < r.length; t++) {
+      var o = r[t];
+      o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+    }
+  }
+  function _createClass(e, r, t) {
+    return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+      writable: !1
+    }), e;
+  }
+  function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[r] = t, e;
+  }
+  function _getPrototypeOf(t) {
+    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+      return t.__proto__ || Object.getPrototypeOf(t);
+    }, _getPrototypeOf(t);
+  }
+  function _inherits(t, e) {
+    if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+    t.prototype = Object.create(e && e.prototype, {
+      constructor: {
+        value: t,
+        writable: !0,
+        configurable: !0
+      }
+    }), Object.defineProperty(t, "prototype", {
+      writable: !1
+    }), e && _setPrototypeOf(t, e);
+  }
+  function _isNativeReflectConstruct() {
+    try {
+      var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    } catch (t) {}
+    return (_isNativeReflectConstruct = function () {
+      return !!t;
+    })();
+  }
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function (r) {
+        return Object.getOwnPropertyDescriptor(e, r).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread2(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+        _defineProperty(e, r, t[r]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+      });
+    }
+    return e;
+  }
+  function _possibleConstructorReturn(t, e) {
+    if (e && ("object" == typeof e || "function" == typeof e)) return e;
+    if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+    return _assertThisInitialized(t);
+  }
+  function _setPrototypeOf(t, e) {
+    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+      return t.__proto__ = e, t;
+    }, _setPrototypeOf(t, e);
+  }
+  function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != typeof i) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : i + "";
+  }
+  function _typeof(o) {
+    "@babel/helpers - typeof";
+
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof(o);
+  }
+
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+  // ======================================================
+  /** vim: et:ts=4:sw=4:sts=4
+   * @license RequireJS 2.3.2 Copyright jQuery Foundation and other contributors.
+   * Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
+   */
+  // Not using strict: uneven strict support in browsers, #392, and causes
+  // problems with requirejs.exec()/transpiler plugins that may not be strict.
+  /* jslint regexp: true, nomen: true, sloppy: true */
+  /* global window, navigator, document, importScripts, setTimeout, opera */
+  var __devfab_requirejs = {};
+  window.__devfab_requirejs = __devfab_requirejs;
+  (function (global, setTimeout) {
+    var requirejs, require, define;
+    var req;
+    var s;
+    var head;
+    var baseElement;
+    var dataMain;
+    var src;
+    var body;
+    var interactiveScript;
+    var currentlyAddingScript;
+    var mainScript;
+    var subPath;
+    var version = '2.3.2';
+    var commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/gm;
+    var cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g;
+    var jsSuffixRegExp = /\.js$/;
+    var currDirRegExp = /^\.\//;
+    var op = Object.prototype;
+    var ostring = op.toString;
+    var hasOwn = op.hasOwnProperty;
+    var isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document);
+    var isWebWorker = !isBrowser && typeof importScripts !== 'undefined';
+    // PS3 indicates loaded and complete, but need to wait for complete
+    // specifically. Sequence is 'loading', 'loaded', execution,
+    // then 'complete'. The UA check is unfortunate, but not sure how
+    // to feature test w/o causing perf issues.
+    var readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ? /^complete$/ : /^(complete|loaded)$/;
+    var defContextName = '_';
+    // Oh the tragedy, detecting opera. See the usage of isOpera for reason.
+    var isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]';
+    var contexts = {};
+    var cfg = {};
+    var globalDefQueue = [];
+    var useInteractive = false;
+
+    // Could match something like ')//comment', do not lose the prefix to comment.
+    function commentReplace(match, singlePrefix) {
+      return singlePrefix || '';
+    }
+    function isFunction(it) {
+      return ostring.call(it) === '[object Function]';
+    }
+    function isArray(it) {
+      return ostring.call(it) === '[object Array]';
+    }
+
+    /**
+     * Helper function for iterating over an array. If the func returns
+     * a true value, it will break out of the loop.
+     */
+    function each(ary, func) {
+      if (ary) {
+        var i;
+        for (i = 0; i < ary.length; i += 1) {
+          // checkmark:disable-line
+          if (ary[i] && func(ary[i], i, ary)) {
+            break;
+          }
+        }
+      }
+    }
+
+    /**
+     * Helper function for iterating over an array backwards. If the func
+     * returns a true value, it will break out of the loop.
+     */
+    function eachReverse(ary, func) {
+      if (ary) {
+        var i;
+        for (i = ary.length - 1; i > -1; i -= 1) {
+          if (ary[i] && func(ary[i], i, ary)) {
+            break;
+          }
+        }
+      }
+    }
+    function hasProp(obj, prop) {
+      return hasOwn.call(obj, prop);
+    }
+    function getOwn(obj, prop) {
+      return hasProp(obj, prop) && obj[prop];
+    }
+
+    /**
+     * Cycles over properties in an object and calls a function for each
+     * property value. If the function returns a truthy value, then the
+     * iteration is stopped.
+     */
+    function eachProp(obj, func) {
+      var prop;
+      for (prop in obj) {
+        if (hasProp(obj, prop)) {
+          if (func(obj[prop], prop)) {
+            break;
+          }
+        }
+      }
+    }
+
+    /**
+     * Simple function to mix in properties from source into target,
+     * but only if target does not already have a property of the same name.
+     */
+    function mixin(target, source, force, deepStringMixin) {
+      if (source) {
+        eachProp(source, function (value, prop) {
+          if (force || !hasProp(target, prop)) {
+            if (deepStringMixin && _typeof(value) === 'object' && value && !isArray(value) && !isFunction(value) && !(value instanceof RegExp)) {
+              if (!target[prop]) {
+                target[prop] = {};
+              }
+              mixin(target[prop], value, force, deepStringMixin);
+            } else {
+              target[prop] = value;
+            }
+          }
+        });
+      }
+      return target;
+    }
+
+    // Similar to Function.prototype.bind, but the 'this' object is specified
+    // first, since it is easier to read/figure out what 'this' will be.
+    function bind(obj, fn) {
+      return function () {
+        return fn.apply(obj, arguments);
+      };
+    }
+    function scripts() {
+      return document.getElementsByTagName('script');
+    }
+    function defaultOnError(err) {
+      throw err;
+    }
+
+    // Allow getting a global that is expressed in
+    // dot notation, like 'a.b.c'.
+    function getGlobal(value) {
+      if (!value) {
+        return value;
+      }
+      var g = global;
+      each(value.split('.'), function (part) {
+        g = g[part];
+      });
+      return g;
+    }
+
+    /**
+     * Constructs an error with a pointer to an URL with more information.
+     * @param {String} id the error ID that maps to an ID on a web page.
+     * @param {String} message human readable error.
+     * @param {Error} [err] the original error, if there is one.
+     *
+     * @returns {Error}
+     */
+    function makeError(id, msg, err, requireModules) {
+      var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
+      e.requireType = id;
+      e.requireModules = requireModules;
+      if (err) {
+        e.originalError = err;
+      }
+      return e;
+    }
+    if (typeof define !== 'undefined') {
+      // If a define is already in play via another AMD loader,
+      // do not overwrite.
+      return;
+    }
+    if (typeof requirejs !== 'undefined') {
+      if (isFunction(requirejs)) {
+        // Do not overwrite an existing requirejs instance.
+        return;
+      }
+      cfg = requirejs;
+      requirejs = undefined;
+    }
+
+    // Allow for a require config object
+    if (typeof require !== 'undefined' && !isFunction(require)) {
+      // assume it is a config object.
+      cfg = require;
+      require = undefined;
+    }
+    function newContext(contextName) {
+      var contextOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var inCheckLoaded;
+      var Module;
+      var context;
+      var handlers;
+      var checkLoadedTimeoutId;
+      var _config = {
+        // Defaults. Do not set a default for map
+        // config to speed up normalize(), which
+        // will run faster if there is no default.
+        waitSeconds: contextOptions.waitSeconds || 30,
+        baseUrl: './',
+        paths: {},
+        bundles: {},
+        pkgs: {},
+        shim: {},
+        config: {}
+      };
+      var registry = {};
+      // registry of just enabled modules, to speed
+      // cycle breaking code when lots of modules
+      // are registered, but not activated.
+      var enabledRegistry = {};
+      var undefEvents = {};
+      var defQueue = [];
+      var _defined = {};
+      var urlFetched = {};
+      var bundlesMap = {};
+      var requireCounter = 1;
+      var unnormalizedCounter = 1;
+
+      /**
+       * Trims the . and .. from an array of path segments.
+       * It will keep a leading path segment if a .. will become
+       * the first path segment, to help with module name lookups,
+       * which act like paths, but can be remapped. But the end result,
+       * all paths that use this function should look normalized.
+       * NOTE: this method MODIFIES the input array.
+       * @param {Array} ary the array of path segments.
+       */
+      function trimDots(ary) {
+        var i, part;
+        for (i = 0; i < ary.length; i++) {
+          part = ary[i];
+          if (part === '.') {
+            ary.splice(i, 1);
+            i -= 1;
+          } else if (part === '..') {
+            // If at the start, or previous value is still ..,
+            // keep them so that when converted to a path it may
+            // still work when converted to a path, even though
+            // as an ID it is less than ideal. In larger point
+            // releases, may be better to just kick out an error.
+            if (i === 0 || i === 1 && ary[2] === '..' || ary[i - 1] === '..') {
+              continue;
+            } else if (i > 0) {
+              ary.splice(i - 1, 2);
+              i -= 2;
+            }
+          }
+        }
+      }
+
+      /**
+       * Given a relative module name, like ./something, normalize it to
+       * a real name that can be mapped to a path.
+       * @param {String} name the relative name
+       * @param {String} baseName a real name that the name arg is relative
+       * to.
+       * @param {Boolean} applyMap apply the map config to the value. Should
+       * only be done if this normalization is for a dependency ID.
+       * @returns {String} normalized name
+       */
+      function normalize(name, baseName, applyMap) {
+        var pkgMain;
+        var mapValue;
+        var nameParts;
+        var i;
+        var j;
+        var nameSegment;
+        var lastIndex;
+        var foundMap;
+        var foundI;
+        var foundStarMap;
+        var starI;
+        var normalizedBaseParts;
+        var baseParts = baseName && baseName.split('/');
+        var map = _config.map;
+        var starMap = map && map['*'];
+
+        // Adjust any relative paths.
+        if (name) {
+          name = name.split('/');
+          lastIndex = name.length - 1;
+
+          // If wanting node ID compatibility, strip .js from end
+          // of IDs. Have to do this here, and not in nameToUrl
+          // because node allows either .js or non .js to map
+          // to same file.
+          if (_config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
+            name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
+          }
+
+          // Starts with a '.' so need the baseName
+          if (name[0].charAt(0) === '.' && baseParts) {
+            // Convert baseName to array, and lop off the last part,
+            // so that . matches that 'directory' and not name of the baseName's
+            // module. For instance, baseName of 'one/two/three', maps to
+            // 'one/two/three.js', but we want the directory, 'one/two' for
+            // this normalization.
+            normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
+            name = normalizedBaseParts.concat(name);
+          }
+          trimDots(name);
+          name = name.join('/');
+        }
+
+        // Apply map config if available.
+        if (applyMap && map && (baseParts || starMap)) {
+          nameParts = name.split('/');
+          for (i = nameParts.length; i > 0; i -= 1) {
+            nameSegment = nameParts.slice(0, i).join('/');
+            if (baseParts) {
+              // Find the longest baseName segment match in the config.
+              // So, do joins on the biggest to smallest lengths of baseParts.
+              var shouldBreakOuterLoop = false;
+              for (j = baseParts.length; j > 0; j -= 1) {
+                mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
+
+                // baseName segment has config, find if it has one for
+                // this name.
+                if (mapValue) {
+                  mapValue = getOwn(mapValue, nameSegment);
+                  if (mapValue) {
+                    // Match, update name to the new value.
+                    foundMap = mapValue;
+                    foundI = i;
+                    shouldBreakOuterLoop = true;
+                    break;
+                  }
+                }
+              }
+              if (shouldBreakOuterLoop) {
+                break;
+              }
+            }
+
+            // Check for a star map match, but just hold on to it,
+            // if there is a shorter segment match later in a matching
+            // config, then favor over this star map.
+            if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
+              foundStarMap = getOwn(starMap, nameSegment);
+              starI = i;
+            }
+          }
+          if (!foundMap && foundStarMap) {
+            foundMap = foundStarMap;
+            foundI = starI;
+          }
+          if (foundMap) {
+            nameParts.splice(0, foundI, foundMap);
+            name = nameParts.join('/');
+          }
+        }
+
+        // If the name points to a package's name, use
+        // the package main instead.
+        pkgMain = getOwn(_config.pkgs, name);
+        return pkgMain || name;
+      }
+      function removeScript(name) {
+        if (isBrowser) {
+          each(scripts(), function (scriptNode) {
+            if (scriptNode.getAttribute('data-requiremodule') === name && scriptNode.getAttribute('data-requirecontext') === context.contextName) {
+              scriptNode.parentNode.removeChild(scriptNode);
+              return true;
+            }
+          });
+        }
+      }
+      function hasPathFallback(id) {
+        var pathConfig = getOwn(_config.paths, id);
+        if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
+          // Pop off the first array value, since it failed, and
+          // retry
+          pathConfig.shift();
+          context.require.undef(id);
+
+          // Custom require that does not do map translation, since
+          // ID is "absolute", already mapped/resolved.
+          context.makeRequire(null, {
+            skipMap: true
+          })([id]);
+          return true;
+        }
+      }
+
+      // Turns a plugin!resource to [plugin, resource]
+      // with the plugin being undefined if the name
+      // did not have a plugin prefix.
+      function splitPrefix(name) {
+        var prefix;
+        var index = name ? name.indexOf('!') : -1;
+        if (index > -1) {
+          prefix = name.substring(0, index);
+          name = name.substring(index + 1, name.length);
+        }
+        return [prefix, name];
+      }
+
+      /**
+       * Creates a module mapping that includes plugin prefix, module
+       * name, and path. If parentModuleMap is provided it will
+       * also normalize the name via require.normalize()
+       *
+       * @param {String} name the module name
+       * @param {String} [parentModuleMap] parent module map
+       * for the module name, used to resolve relative names.
+       * @param {Boolean} isNormalized: is the ID already normalized.
+       * This is true if this call is done for a define() module ID.
+       * @param {Boolean} applyMap: apply the map config to the ID.
+       * Should only be true if this map is for a dependency.
+       *
+       * @returns {Object}
+       */
+      function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
+        var url;
+        var pluginModule;
+        var suffix;
+        var nameParts;
+        var prefix = null;
+        var parentName = parentModuleMap ? parentModuleMap.name : null;
+        var originalName = name;
+        var isDefine = true;
+        var normalizedName = '';
+
+        // If no name, then it means it is a require call, generate an
+        // internal name.
+        if (!name) {
+          isDefine = false;
+          name = '_@r' + (requireCounter += 1);
+        }
+        nameParts = splitPrefix(name);
+        prefix = nameParts[0];
+        name = nameParts[1];
+        if (prefix) {
+          prefix = normalize(prefix, parentName, applyMap);
+          pluginModule = getOwn(_defined, prefix);
+        }
+
+        // Account for relative paths if there is a base name.
+        if (name) {
+          if (prefix) {
+            if (pluginModule && pluginModule.normalize) {
+              // Plugin is loaded, use its normalize method.
+              normalizedName = pluginModule.normalize(name, function (name) {
+                return normalize(name, parentName, applyMap);
+              });
+            } else {
+              // If nested plugin references, then do not try to
+              // normalize, as it will not normalize correctly. This
+              // places a restriction on resourceIds, and the longer
+              // term solution is not to normalize until plugins are
+              // loaded and all normalizations to allow for async
+              // loading of a loader plugin. But for now, fixes the
+              // common uses. Details in #1131
+              normalizedName = name.indexOf('!') === -1 ? normalize(name, parentName, applyMap) : name;
+            }
+          } else {
+            // A regular module.
+            normalizedName = normalize(name, parentName, applyMap);
+
+            // Normalized name may be a plugin ID due to map config
+            // application in normalize. The map config values must
+            // already be normalized, so do not need to redo that part.
+            nameParts = splitPrefix(normalizedName);
+            prefix = nameParts[0];
+            normalizedName = nameParts[1];
+            isNormalized = true;
+            url = context.nameToUrl(normalizedName);
+          }
+        }
+
+        // If the id is a plugin id that cannot be determined if it needs
+        // normalization, stamp it with a unique ID so two matching relative
+        // ids that may conflict can be separate.
+        suffix = prefix && !pluginModule && !isNormalized ? '_unnormalized' + (unnormalizedCounter += 1) : '';
+        return {
+          prefix: prefix,
+          name: normalizedName,
+          parentMap: parentModuleMap,
+          unnormalized: !!suffix,
+          url: url,
+          originalName: originalName,
+          isDefine: isDefine,
+          id: (prefix ? prefix + '!' + normalizedName : normalizedName) + suffix
+        };
+      }
+      function getModule(depMap) {
+        var id = depMap.id;
+        var mod = getOwn(registry, id);
+        if (!mod) {
+          mod = registry[id] = new context.Module(depMap);
+        }
+        return mod;
+      }
+      function on(depMap, name, fn) {
+        var id = depMap.id;
+        var mod = getOwn(registry, id);
+        if (hasProp(_defined, id) && (!mod || mod.defineEmitComplete)) {
+          if (name === 'defined') {
+            fn(_defined[id]);
+          }
+        } else {
+          mod = getModule(depMap);
+          if (mod.error && name === 'error') {
+            fn(mod.error);
+          } else {
+            mod.on(name, fn);
+          }
+        }
+      }
+      function onError(err, errback) {
+        var ids = err.requireModules;
+        var notified = false;
+        if (errback) {
+          errback(err);
+        } else {
+          each(ids, function (id) {
+            var mod = getOwn(registry, id);
+            if (mod) {
+              // Set error on module, so it skips timeout checks.
+              mod.error = err;
+              if (mod.events.error) {
+                notified = true;
+                mod.emit('error', err);
+              }
+            }
+          });
+          if (!notified) {
+            req.onError(err);
+          }
+        }
+      }
+
+      /**
+       * Internal method to transfer globalQueue items to this context's
+       * defQueue.
+       */
+      function takeGlobalQueue() {
+        // Push all the globalDefQueue items into the context's defQueue
+        if (globalDefQueue.length) {
+          each(globalDefQueue, function (queueItem) {
+            var id = queueItem[0];
+            if (typeof id === 'string') {
+              context.defQueueMap[id] = true;
+            }
+            defQueue.push(queueItem);
+          });
+          globalDefQueue = [];
+        }
+      }
+      handlers = {
+        require: function require(mod) {
+          if (mod.require) {
+            return mod.require;
+          } else {
+            return mod.require = context.makeRequire(mod.map);
+          }
+        },
+        exports: function exports(mod) {
+          mod.usingExports = true;
+          if (mod.map.isDefine) {
+            if (mod.exports) {
+              _defined[mod.map.id] = mod.exports;
+            } else {
+              mod.exports = _defined[mod.map.id] = {};
+            }
+          }
+        },
+        module: function module(mod) {
+          if (mod.module) {
+            return mod.module;
+          } else {
+            return mod.module = {
+              id: mod.map.id,
+              uri: mod.map.url,
+              config: function config() {
+                return getOwn(_config.config, mod.map.id) || {};
+              },
+              exports: mod.exports || (mod.exports = {})
+            };
+          }
+        }
+      };
+      function cleanRegistry(id) {
+        // Clean up machinery used for waiting modules.
+        delete registry[id];
+        delete enabledRegistry[id];
+      }
+      function breakCycle(mod, traced, processed) {
+        var id = mod.map.id;
+        if (mod.error) {
+          mod.emit('error', mod.error);
+        } else {
+          traced[id] = true;
+          each(mod.depMaps, function (depMap, i) {
+            var depId = depMap.id;
+            var dep = getOwn(registry, depId);
+
+            // Only force things that have not completed
+            // being defined, so still in the registry,
+            // and only if it has not been matched up
+            // in the module already.
+            if (dep && !mod.depMatched[i] && !processed[depId]) {
+              if (getOwn(traced, depId)) {
+                mod.defineDep(i, _defined[depId]);
+                mod.check(); // pass false?
+              } else {
+                breakCycle(dep, traced, processed);
+              }
+            }
+          });
+          processed[id] = true;
+        }
+      }
+      function checkLoaded() {
+        var err;
+        var usingPathFallback;
+        var waitInterval = _config.waitSeconds * 1000;
+        // It is possible to disable the wait interval by using waitSeconds of 0.
+        var expired = waitInterval && context.startTime + waitInterval < new Date().getTime();
+        var noLoads = [];
+        var reqCalls = [];
+        var stillLoading = false;
+        var needCycleCheck = true;
+
+        // Do not bother if this call was a result of a cycle break.
+        if (inCheckLoaded) {
+          return;
+        }
+        inCheckLoaded = true;
+
+        // Figure out the state of all the modules.
+        eachProp(enabledRegistry, function (mod) {
+          var map = mod.map;
+          var modId = map.id;
+
+          // Skip things that are not enabled or in error state.
+          if (!mod.enabled) {
+            return;
+          }
+          if (!map.isDefine) {
+            reqCalls.push(mod);
+          }
+          if (!mod.error) {
+            // If the module should be executed, and it has not
+            // been inited and time is up, remember it.
+            if (!mod.inited && expired) {
+              if (hasPathFallback(modId)) {
+                usingPathFallback = true;
+                stillLoading = true;
+              } else {
+                noLoads.push(modId);
+                removeScript(modId);
+              }
+            } else if (!mod.inited && mod.fetched && map.isDefine) {
+              stillLoading = true;
+              if (!map.prefix) {
+                // No reason to keep looking for unfinished
+                // loading. If the only stillLoading is a
+                // plugin resource though, keep going,
+                // because it may be that a plugin resource
+                // is waiting on a non-plugin cycle.
+                return needCycleCheck = false;
+              }
+            }
+          }
+        });
+        if (expired && noLoads.length) {
+          // If wait time expired, throw error of unloaded modules.
+          err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
+          err.contextName = context.contextName;
+          return onError(err);
+        }
+
+        // Not expired, check for a cycle.
+        if (needCycleCheck) {
+          each(reqCalls, function (mod) {
+            breakCycle(mod, {}, {});
+          });
+        }
+
+        // If still waiting on loads, and the waiting load is something
+        // other than a plugin resource, or there are still outstanding
+        // scripts, then just try back later.
+        if ((!expired || usingPathFallback) && stillLoading) {
+          // Something is still waiting to load. Wait for it, but only
+          // if a timeout is not already in effect.
+          if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
+            checkLoadedTimeoutId = setTimeout(function () {
+              checkLoadedTimeoutId = 0;
+              checkLoaded();
+            }, 50);
+          }
+        }
+        inCheckLoaded = false;
+      }
+      Module = function Module(map) {
+        this.events = getOwn(undefEvents, map.id) || {};
+        this.map = map;
+        this.shim = getOwn(_config.shim, map.id);
+        this.depExports = [];
+        this.depMaps = [];
+        this.depMatched = [];
+        this.pluginMaps = {};
+        this.depCount = 0;
+
+        /* this.exports this.factory
+        this.depMaps = [],
+        this.enabled, this.fetched
+        */
+      };
+      Module.prototype = {
+        init: function init(depMaps, factory, errback, options) {
+          options = options || {};
+
+          // Do not do more inits if already done. Can happen if there
+          // are multiple define calls for the same module. That is not
+          // a normal, common case, but it is also not unexpected.
+          if (this.inited) {
+            return;
+          }
+          this.factory = factory;
+          if (errback) {
+            // Register for errors on this module.
+            this.on('error', errback);
+          } else if (this.events.error) {
+            // If no errback already, but there are error listeners
+            // on this module, set up an errback to pass to the deps.
+            errback = bind(this, function (err) {
+              this.emit('error', err);
+            });
+          }
+
+          // Do a copy of the dependency array, so that
+          // source inputs are not modified. For example
+          // "shim" deps are passed in here directly, and
+          // doing a direct modification of the depMaps array
+          // would affect that config.
+          this.depMaps = depMaps && depMaps.slice(0);
+          this.errback = errback;
+
+          // Indicate this module has be initialized
+          this.inited = true;
+          this.ignore = options.ignore;
+
+          // Could have option to init this module in enabled mode,
+          // or could have been previously marked as enabled. However,
+          // the dependencies are not known until init is called. So
+          // if enabled previously, now trigger dependencies as enabled.
+          if (options.enabled || this.enabled) {
+            // Enable this module and dependencies.
+            // Will call this.check()
+            this.enable();
+          } else {
+            this.check();
+          }
+        },
+        defineDep: function defineDep(i, depExports) {
+          // Because of cycles, defined callback for a given
+          // export can be called more than once.
+          if (!this.depMatched[i]) {
+            this.depMatched[i] = true;
+            this.depCount -= 1;
+            this.depExports[i] = depExports;
+          }
+        },
+        fetch: function fetch() {
+          if (this.fetched) {
+            return;
+          }
+          this.fetched = true;
+          context.startTime = new Date().getTime();
+          var map = this.map;
+
+          // If the manager is for a plugin managed resource,
+          // ask the plugin to load it now.
+          if (this.shim) {
+            context.makeRequire(this.map, {
+              enableBuildCallback: true
+            })(this.shim.deps || [], bind(this, function () {
+              return map.prefix ? this.callPlugin() : this.load();
+            }));
+          } else {
+            // Regular dependency.
+            return map.prefix ? this.callPlugin() : this.load();
+          }
+        },
+        load: function load() {
+          var url = this.map.url;
+
+          // Regular dependency.
+          if (!urlFetched[url]) {
+            urlFetched[url] = true;
+            context.load(this.map.id, url);
+          }
+        },
+        /**
+         * Checks if the module is ready to define itself, and if so,
+         * define it.
+         */
+        check: function check() {
+          if (!this.enabled || this.enabling) {
+            return;
+          }
+          var err;
+          var cjsModule;
+          var id = this.map.id;
+          var depExports = this.depExports;
+          var exports = this.exports;
+          var factory = this.factory;
+          if (!this.inited) {
+            // Only fetch if not already in the defQueue.
+            if (!hasProp(context.defQueueMap, id)) {
+              this.fetch();
+            }
+          } else if (this.error) {
+            this.emit('error', this.error);
+          } else if (!this.defining) {
+            // The factory could trigger another require call
+            // that would result in checking this module to
+            // define itself again. If already in the process
+            // of doing that, skip this work.
+            this.defining = true;
+            if (this.depCount < 1 && !this.defined) {
+              if (isFunction(factory)) {
+                // If there is an error listener, favor passing
+                // to that instead of throwing an error. However,
+                // only do it for define()'d  modules. require
+                // errbacks should not be called for failures in
+                // their callbacks (#699). However if a global
+                // onError is set, use that.
+                if (this.events.error && this.map.isDefine || req.onError !== defaultOnError) {
+                  try {
+                    exports = context.execCb(id, factory, depExports, exports);
+                  } catch (e) {
+                    err = e;
+                  }
+                } else {
+                  exports = context.execCb(id, factory, depExports, exports);
+                }
+
+                // Favor return value over exports. If node/cjs in play,
+                // then will not have a return value anyway. Favor
+                // module.exports assignment over exports object.
+                if (this.map.isDefine && exports === undefined) {
+                  cjsModule = this.module;
+                  if (cjsModule) {
+                    exports = cjsModule.exports;
+                  } else if (this.usingExports) {
+                    // exports already set the defined value.
+                    exports = this.exports;
+                  }
+                }
+                if (err) {
+                  err.requireMap = this.map;
+                  err.requireModules = this.map.isDefine ? [this.map.id] : null;
+                  err.requireType = this.map.isDefine ? 'define' : 'require';
+                  return onError(this.error = err);
+                }
+              } else {
+                // Just a literal value
+                exports = factory;
+              }
+              this.exports = exports;
+              if (this.map.isDefine && !this.ignore) {
+                _defined[id] = exports;
+                if (req.onResourceLoad) {
+                  var resLoadMaps = [];
+                  each(this.depMaps, function (depMap) {
+                    resLoadMaps.push(depMap.normalizedMap || depMap);
+                  });
+                  req.onResourceLoad(context, this.map, resLoadMaps);
+                }
+              }
+
+              // Clean up
+              cleanRegistry(id);
+              this.defined = true;
+            }
+
+            // Finished the define stage. Allow calling check again
+            // to allow define notifications below in the case of a
+            // cycle.
+            this.defining = false;
+            if (this.defined && !this.defineEmitted) {
+              this.defineEmitted = true;
+              this.emit('defined', this.exports);
+              this.defineEmitComplete = true;
+            }
+          }
+        },
+        callPlugin: function callPlugin() {
+          var map = this.map;
+          var id = map.id;
+          // Map already normalized the prefix.
+          var pluginMap = makeModuleMap(map.prefix);
+
+          // Mark this as a dependency for this plugin, so it
+          // can be traced for cycles.
+          this.depMaps.push(pluginMap);
+          on(pluginMap, 'defined', bind(this, function (plugin) {
+            var load;
+            var normalizedMap;
+            var normalizedMod;
+            var bundleId = getOwn(bundlesMap, this.map.id);
+            var name = this.map.name;
+            var parentName = this.map.parentMap ? this.map.parentMap.name : null;
+            var localRequire = context.makeRequire(map.parentMap, {
+              enableBuildCallback: true
+            });
+
+            // If current map is not normalized, wait for that
+            // normalized name to load instead of continuing.
+            if (this.map.unnormalized) {
+              // Normalize the ID if the plugin allows it.
+              if (plugin.normalize) {
+                name = plugin.normalize(name, function (name) {
+                  return normalize(name, parentName, true);
+                }) || '';
+              }
+
+              // prefix and name should already be normalized, no need
+              // for applying map config again either.
+              normalizedMap = makeModuleMap(map.prefix + '!' + name, this.map.parentMap);
+              on(normalizedMap, 'defined', bind(this, function (value) {
+                this.map.normalizedMap = normalizedMap;
+                this.init([], function () {
+                  return value;
+                }, null, {
+                  enabled: true,
+                  ignore: true
+                });
+              }));
+              normalizedMod = getOwn(registry, normalizedMap.id);
+              if (normalizedMod) {
+                // Mark this as a dependency for this plugin, so it
+                // can be traced for cycles.
+                this.depMaps.push(normalizedMap);
+                if (this.events.error) {
+                  normalizedMod.on('error', bind(this, function (err) {
+                    this.emit('error', err);
+                  }));
+                }
+                normalizedMod.enable();
+              }
+              return;
+            }
+
+            // If a paths config, then just load that file instead to
+            // resolve the plugin, as it is built into that paths layer.
+            if (bundleId) {
+              this.map.url = context.nameToUrl(bundleId);
+              this.load();
+              return;
+            }
+            load = bind(this, function (value) {
+              this.init([], function () {
+                return value;
+              }, null, {
+                enabled: true
+              });
+            });
+            load.error = bind(this, function (err) {
+              this.inited = true;
+              this.error = err;
+              err.requireModules = [id];
+
+              // Remove temp unnormalized modules for this module,
+              // since they will never be resolved otherwise now.
+              eachProp(registry, function (mod) {
+                if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
+                  cleanRegistry(mod.map.id);
+                }
+              });
+              onError(err);
+            });
+
+            // Allow plugins to load other code without having to know the
+            // context or how to 'complete' the load.
+            load.fromText = bind(this, function (text, textAlt) {
+              /* jslint evil: true */
+              var moduleName = map.name;
+              var moduleMap = makeModuleMap(moduleName);
+              var hasInteractive = useInteractive;
+
+              // As of 2.1.0, support just passing the text, to reinforce
+              // fromText only being called once per resource. Still
+              // support old style of passing moduleName but discard
+              // that moduleName in favor of the internal ref.
+              if (textAlt) {
+                text = textAlt;
+              }
+
+              // Turn off interactive script matching for IE for any define
+              // calls in the text, then turn it back on at the end.
+              if (hasInteractive) {
+                useInteractive = false;
+              }
+
+              // Prime the system by creating a module instance for
+              // it.
+              getModule(moduleMap);
+
+              // Transfer any config to this other module.
+              if (hasProp(_config.config, id)) {
+                _config.config[moduleName] = _config.config[id];
+              }
+              try {
+                req.exec(text);
+              } catch (e) {
+                return onError(makeError('fromtexteval', 'fromText eval for ' + id + ' failed: ' + e, e, [id]));
+              }
+              if (hasInteractive) {
+                useInteractive = true;
+              }
+
+              // Mark this as a dependency for the plugin
+              // resource
+              this.depMaps.push(moduleMap);
+
+              // Support anonymous modules.
+              context.completeLoad(moduleName);
+
+              // Bind the value of that module to the value for this
+              // resource ID.
+              localRequire([moduleName], load);
+            });
+
+            // Use parentName here since the plugin's name is not reliable,
+            // could be some weird string with no path that actually wants to
+            // reference the parentName's path.
+            plugin.load(map.name, localRequire, load, _config);
+          }));
+          context.enable(pluginMap, this);
+          this.pluginMaps[pluginMap.id] = pluginMap;
+        },
+        enable: function enable() {
+          enabledRegistry[this.map.id] = this;
+          this.enabled = true;
+
+          // Set flag mentioning that the module is enabling,
+          // so that immediate calls to the defined callbacks
+          // for dependencies do not trigger inadvertent load
+          // with the depCount still being zero.
+          this.enabling = true;
+
+          // Enable each dependency
+          each(this.depMaps, bind(this, function (depMap, i) {
+            var id, mod, handler;
+            if (typeof depMap === 'string') {
+              // Dependency needs to be converted to a depMap
+              // and wired up to this module.
+              depMap = makeModuleMap(depMap, this.map.isDefine ? this.map : this.map.parentMap, false, !this.skipMap);
+              this.depMaps[i] = depMap;
+              handler = getOwn(handlers, depMap.id);
+              if (handler) {
+                this.depExports[i] = handler(this);
+                return;
+              }
+              this.depCount += 1;
+              on(depMap, 'defined', bind(this, function (depExports) {
+                if (this.undefed) {
+                  return;
+                }
+                this.defineDep(i, depExports);
+                this.check();
+              }));
+              if (this.errback) {
+                on(depMap, 'error', bind(this, this.errback));
+              } else if (this.events.error) {
+                // No direct errback on this module, but something
+                // else is listening for errors, so be sure to
+                // propagate the error correctly.
+                on(depMap, 'error', bind(this, function (err) {
+                  this.emit('error', err);
+                }));
+              }
+            }
+            id = depMap.id;
+            mod = registry[id];
+
+            // Skip special modules like 'require', 'exports', 'module'
+            // Also, don't call enable if it is already enabled,
+            // important in circular dependency cases.
+            if (!hasProp(handlers, id) && mod && !mod.enabled) {
+              context.enable(depMap, this);
+            }
+          }));
+
+          // Enable each plugin that is used in
+          // a dependency
+          eachProp(this.pluginMaps, bind(this, function (pluginMap) {
+            var mod = getOwn(registry, pluginMap.id);
+            if (mod && !mod.enabled) {
+              context.enable(pluginMap, this);
+            }
+          }));
+          this.enabling = false;
+          this.check();
+        },
+        on: function on(name, cb) {
+          var cbs = this.events[name];
+          if (!cbs) {
+            cbs = this.events[name] = [];
+          }
+          cbs.push(cb);
+        },
+        emit: function emit(name, evt) {
+          each(this.events[name], function (cb) {
+            cb(evt);
+          });
+          if (name === 'error') {
+            // Now that the error handler was triggered, remove
+            // the listeners, since this broken Module instance
+            // can stay around for a while in the registry.
+            delete this.events[name];
+          }
+        }
+      };
+      function callGetModule(args) {
+        // Skip modules already defined.
+        if (!hasProp(_defined, args[0])) {
+          getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
+        }
+      }
+      function removeListener(node, func, name, ieName) {
+        // Favor detachEvent because of IE9
+        // issue, see attachEvent/addEventListener comment elsewhere
+        // in this file.
+        if (node.detachEvent && !isOpera) {
+          // Probably IE. If not it will throw an error, which will be
+          // useful to know.
+          if (ieName) {
+            node.detachEvent(ieName, func);
+          }
+        } else {
+          node.removeEventListener(name, func, false);
+        }
+      }
+
+      /**
+       * Given an event from a script node, get the requirejs info from it,
+       * and then removes the event listeners on the node.
+       * @param {Event} evt
+       * @returns {Object}
+       */
+      function getScriptData(evt) {
+        // Using currentTarget instead of target for Firefox 2.0's sake. Not
+        // all old browsers will be supported, but this one was easy enough
+        // to support and still makes sense.
+        var node = evt.currentTarget || evt.srcElement;
+
+        // Remove the listeners once here.
+        removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
+        removeListener(node, context.onScriptError, 'error');
+        return {
+          node: node,
+          id: node && node.getAttribute('data-requiremodule')
+        };
+      }
+      function intakeDefines() {
+        var args;
+
+        // Any defined modules in the global queue, intake them now.
+        takeGlobalQueue();
+
+        // Make sure any remaining defQueue items get properly processed.
+        while (defQueue.length) {
+          args = defQueue.shift();
+          if (args[0] === null) {
+            return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
+          } else {
+            // args are id, deps, factory. Should be normalized by the
+            // define() function.
+            callGetModule(args);
+          }
+        }
+        context.defQueueMap = {};
+      }
+      context = {
+        config: _config,
+        contextName: contextName,
+        registry: registry,
+        defined: _defined,
+        urlFetched: urlFetched,
+        defQueue: defQueue,
+        defQueueMap: {},
+        Module: Module,
+        makeModuleMap: makeModuleMap,
+        nextTick: req.nextTick,
+        onError: onError,
+        /**
+         * Set a configuration for the context.
+         * @param {Object} cfg config object to integrate.
+         */
+        configure: function configure(cfg) {
+          // Make sure the baseUrl ends in a slash.
+          if (cfg.baseUrl) {
+            if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
+              cfg.baseUrl += '/';
+            }
+          }
+
+          // Convert old style urlArgs string to a function.
+          if (typeof cfg.urlArgs === 'string') {
+            var urlArgs = cfg.urlArgs;
+            cfg.urlArgs = function (id, url) {
+              return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
+            };
+          }
+
+          // Save off the paths since they require special processing,
+          // they are additive.
+          var shim = _config.shim;
+          var objs = {
+            paths: true,
+            bundles: true,
+            config: true,
+            map: true
+          };
+          eachProp(cfg, function (value, prop) {
+            if (objs[prop]) {
+              if (!_config[prop]) {
+                _config[prop] = {};
+              }
+              mixin(_config[prop], value, true, true);
+            } else {
+              _config[prop] = value;
+            }
+          });
+
+          // Reverse map the bundles
+          if (cfg.bundles) {
+            eachProp(cfg.bundles, function (value, prop) {
+              each(value, function (v) {
+                if (v !== prop) {
+                  bundlesMap[v] = prop;
+                }
+              });
+            });
+          }
+
+          // Merge shim
+          if (cfg.shim) {
+            eachProp(cfg.shim, function (value, id) {
+              // Normalize the structure
+              if (isArray(value)) {
+                value = {
+                  deps: value
+                };
+              }
+              if ((value.exports || value.init) && !value.exportsFn) {
+                value.exportsFn = context.makeShimExports(value);
+              }
+              shim[id] = value;
+            });
+            _config.shim = shim;
+          }
+
+          // Adjust packages if necessary.
+          if (cfg.packages) {
+            each(cfg.packages, function (pkgObj) {
+              var location, name;
+              pkgObj = typeof pkgObj === 'string' ? {
+                name: pkgObj
+              } : pkgObj;
+              name = pkgObj.name;
+              location = pkgObj.location;
+              if (location) {
+                _config.paths[name] = pkgObj.location;
+              }
+
+              // Save pointer to main module ID for pkg name.
+              // Remove leading dot in main, so main paths are normalized,
+              // and remove any trailing .js, since different package
+              // envs have different conventions: some use a module name,
+              // some use a file name.
+              _config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main').replace(currDirRegExp, '').replace(jsSuffixRegExp, '');
+            });
+          }
+
+          // If there are any "waiting to execute" modules in the registry,
+          // update the maps for them, since their info, like URLs to load,
+          // may have changed.
+          eachProp(registry, function (mod, id) {
+            // If module already has init called, since it is too
+            // late to modify them, and ignore unnormalized ones
+            // since they are transient.
+            if (!mod.inited && !mod.map.unnormalized) {
+              mod.map = makeModuleMap(id, null, true);
+            }
+          });
+
+          // If a deps array or a config callback is specified, then call
+          // require with those args. This is useful when require is defined as a
+          // config object before require.js is loaded.
+          if (cfg.deps || cfg.callback) {
+            context.require(cfg.deps || [], cfg.callback);
+          }
+        },
+        makeShimExports: function makeShimExports(value) {
+          function fn() {
+            var ret;
+            if (value.init) {
+              ret = value.init.apply(global, arguments);
+            }
+            return ret || value.exports && getGlobal(value.exports);
+          }
+          return fn;
+        },
+        makeRequire: function makeRequire(relMap, options) {
+          options = options || {};
+          function localRequire(deps, callback, errback) {
+            var id, map, requireMod;
+            if (options.enableBuildCallback && callback && isFunction(callback)) {
+              callback.__requireJsBuild = true;
+            }
+            if (typeof deps === 'string') {
+              if (isFunction(callback)) {
+                // Invalid call
+                return onError(makeError('requireargs', 'Invalid require call'), errback);
+              }
+
+              // If require|exports|module are requested, get the
+              // value for them from the special handlers. Caveat:
+              // this only works while module is being defined.
+              if (relMap && hasProp(handlers, deps)) {
+                return handlers[deps](registry[relMap.id]);
+              }
+
+              // Synchronous access to one module. If require.get is
+              // available (as in the Node adapter), prefer that.
+              if (req.get) {
+                return req.get(context, deps, relMap, localRequire);
+              }
+
+              // Normalize module name, if it contains . or ..
+              map = makeModuleMap(deps, relMap, false, true);
+              id = map.id;
+              if (!hasProp(_defined, id)) {
+                return onError(makeError('notloaded', 'Module name "' + id + '" has not been loaded yet for context: ' + contextName + (relMap ? '' : '. Use require([])')));
+              }
+              return _defined[id];
+            }
+
+            // Grab defines waiting in the global queue.
+            intakeDefines();
+
+            // Mark all the dependencies as needing to be loaded.
+            context.nextTick(function () {
+              // Some defines could have been added since the
+              // require call, collect them.
+              intakeDefines();
+              requireMod = getModule(makeModuleMap(null, relMap));
+
+              // Store if map config should be applied to this require
+              // call for dependencies.
+              requireMod.skipMap = options.skipMap;
+              requireMod.init(deps, callback, errback, {
+                enabled: true
+              });
+              checkLoaded();
+            });
+            return localRequire;
+          }
+          mixin(localRequire, {
+            isBrowser: isBrowser,
+            /**
+             * Converts a module name + .extension into an URL path.
+             * *Requires* the use of a module name. It does not support using
+             * plain URLs like nameToUrl.
+             */
+            toUrl: function toUrl(moduleNamePlusExt) {
+              var ext;
+              var index = moduleNamePlusExt.lastIndexOf('.');
+              var segment = moduleNamePlusExt.split('/')[0];
+              var isRelative = segment === '.' || segment === '..';
+
+              // Have a file extension alias, and it is not the
+              // dots from a relative path.
+              if (index !== -1 && (!isRelative || index > 1)) {
+                ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
+                moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
+              }
+              return context.nameToUrl(normalize(moduleNamePlusExt, relMap && relMap.id, true), ext, true);
+            },
+            defined: function defined(id) {
+              return hasProp(_defined, makeModuleMap(id, relMap, false, true).id);
+            },
+            specified: function specified(id) {
+              id = makeModuleMap(id, relMap, false, true).id;
+              return hasProp(_defined, id) || hasProp(registry, id);
+            }
+          });
+
+          // Only allow undef on top level require calls
+          if (!relMap) {
+            localRequire.undef = function (id) {
+              // Bind any waiting define() calls to this context,
+              // fix for #408
+              takeGlobalQueue();
+              var map = makeModuleMap(id, relMap, true);
+              var mod = getOwn(registry, id);
+              mod.undefed = true;
+              removeScript(id);
+              delete _defined[id];
+              delete urlFetched[map.url];
+              delete undefEvents[id];
+
+              // Clean queued defines too. Go backwards
+              // in array so that the splices do not
+              // mess up the iteration.
+              eachReverse(defQueue, function (args, i) {
+                if (args[0] === id) {
+                  defQueue.splice(i, 1);
+                }
+              });
+              delete context.defQueueMap[id];
+              if (mod) {
+                // Hold on to listeners in case the
+                // module will be attempted to be reloaded
+                // using a different config.
+                if (mod.events.defined) {
+                  undefEvents[id] = mod.events;
+                }
+                cleanRegistry(id);
+              }
+            };
+          }
+          return localRequire;
+        },
+        /**
+         * Called to enable a module if it is still in the registry
+         * awaiting enablement. A second arg, parent, the parent module,
+         * is passed in for context, when this method is overridden by
+         * the optimizer. Not shown here to keep code compact.
+         */
+        enable: function enable(depMap) {
+          var mod = getOwn(registry, depMap.id);
+          if (mod) {
+            getModule(depMap).enable();
+          }
+        },
+        /**
+         * Internal method used by environment adapters to complete a load event.
+         * A load event could be a script load or just a load pass from a synchronous
+         * load call.
+         * @param {String} moduleName the name of the module to potentially complete.
+         */
+        completeLoad: function completeLoad(moduleName) {
+          var found;
+          var args;
+          var mod;
+          var shim = getOwn(_config.shim, moduleName) || {};
+          var shExports = shim.exports;
+          takeGlobalQueue();
+          while (defQueue.length) {
+            args = defQueue.shift();
+            if (args[0] === null) {
+              args[0] = moduleName;
+              // If already found an anonymous module and bound it
+              // to this name, then this is some other anon module
+              // waiting for its completeLoad to fire.
+              if (found) {
+                break;
+              }
+              found = true;
+            } else if (args[0] === moduleName) {
+              // Found matching define call for this script!
+              found = true;
+            }
+            callGetModule(args);
+          }
+          context.defQueueMap = {};
+
+          // Do this after the cycle of callGetModule in case the result
+          // of those calls/init calls changes the registry.
+          mod = getOwn(registry, moduleName);
+          if (!found && !hasProp(_defined, moduleName) && mod && !mod.inited) {
+            if (_config.enforceDefine && (!shExports || !getGlobal(shExports))) {
+              if (hasPathFallback(moduleName)) {
+                return;
+              } else {
+                return onError(makeError('nodefine', 'No define call for ' + moduleName, null, [moduleName]));
+              }
+            } else {
+              // A script that does not call define(), so just simulate
+              // the call for it.
+              callGetModule([moduleName, shim.deps || [], shim.exportsFn]);
+            }
+          }
+          checkLoaded();
+        },
+        /**
+         * Converts a module name to a file path. Supports cases where
+         * moduleName may actually be just an URL.
+         * Note that it **does not** call normalize on the moduleName,
+         * it is assumed to have already been normalized. This is an
+         * internal API, not a public one. Use toUrl for the public API.
+         */
+        nameToUrl: function nameToUrl(moduleName, ext, skipExt) {
+          var paths;
+          var syms;
+          var i;
+          var parentModule;
+          var url;
+          var parentPath;
+          var bundleId;
+          var pkgMain = getOwn(_config.pkgs, moduleName);
+          if (pkgMain) {
+            moduleName = pkgMain;
+          }
+          bundleId = getOwn(bundlesMap, moduleName);
+          if (bundleId) {
+            return context.nameToUrl(bundleId, ext, skipExt);
+          }
+
+          // If a colon is in the URL, it indicates a protocol is used and it is just
+          // an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
+          // or ends with .js, then assume the user meant to use an url and not a module id.
+          // The slash is important for protocol-less URLs as well as full paths.
+          if (req.jsExtRegExp.test(moduleName)) {
+            // Just a plain path, not module name lookup, so just return it.
+            // Add extension if it is included. This is a bit wonky, only non-.js things pass
+            // an extension, this method probably needs to be reworked.
+            url = moduleName + (ext || '');
+          } else {
+            // A module that needs to be converted to a path.
+            paths = _config.paths;
+            syms = moduleName.split('/');
+            // For each module name segment, see if there is a path
+            // registered for it. Start with most specific name
+            // and work up from it.
+            for (i = syms.length; i > 0; i -= 1) {
+              parentModule = syms.slice(0, i).join('/');
+              parentPath = getOwn(paths, parentModule);
+              if (parentPath) {
+                // If an array, it means there are a few choices,
+                // Choose the one that is desired
+                if (isArray(parentPath)) {
+                  parentPath = parentPath[0];
+                }
+                syms.splice(0, i, parentPath);
+                break;
+              }
+            }
+
+            // Join the path parts together, then figure out if baseUrl is needed.
+            url = syms.join('/');
+            url += ext || (/^data:|^blob:|\?/.test(url) || skipExt ? '' : '.js');
+            url = (url.charAt(0) === '/' || url.match(/^[\w+.-]+:/) ? '' : _config.baseUrl) + url;
+          }
+          return _config.urlArgs && !/^blob:/.test(url) ? url + _config.urlArgs(moduleName, url) : url;
+        },
+        // Delegates to req.load. Broken out as a separate function to
+        // allow overriding in the optimizer.
+        load: function load(id, url) {
+          req.load(context, id, url);
+        },
+        /**
+         * Executes a module callback function. Broken out as a separate function
+         * solely to allow the build system to sequence the files in the built
+         * layer in the right sequence.
+         *
+         * @private
+         */
+        execCb: function execCb(name, callback, args, exports) {
+          return callback.apply(exports, args);
+        },
+        /**
+         * callback for script loads, used to check status of loading.
+         *
+         * @param {Event} evt the event from the browser for the script
+         * that was loaded.
+         */
+        onScriptLoad: function onScriptLoad(evt) {
+          // Using currentTarget instead of target for Firefox 2.0's sake. Not
+          // all old browsers will be supported, but this one was easy enough
+          // to support and still makes sense.
+          if (evt.type === 'load' || readyRegExp.test((evt.currentTarget || evt.srcElement).readyState)) {
+            // Reset interactive script so a script node is not held onto for
+            // to long.
+            interactiveScript = null;
+
+            // Pull out the name of the module and the context.
+            var data = getScriptData(evt);
+            context.completeLoad(data.id);
+          }
+        },
+        /**
+         * Callback for script errors.
+         */
+        onScriptError: function onScriptError(evt) {
+          var data = getScriptData(evt);
+          if (!hasPathFallback(data.id)) {
+            var parents = [];
+            eachProp(registry, function (value, key) {
+              if (key.indexOf('_@r') !== 0) {
+                each(value.depMaps, function (depMap) {
+                  if (depMap.id === data.id) {
+                    parents.push(key);
+                    return true;
+                  }
+                });
+              }
+            });
+            return onError(makeError('scripterror', 'Script error for "' + data.id + (parents.length ? '", needed by: ' + parents.join(', ') : '"'), evt, [data.id]));
+          }
+        }
+      };
+      context.require = context.makeRequire();
+      return context;
+    }
+
+    /**
+     * Main entry point.
+     *
+     * If the only argument to require is a string, then the module that
+     * is represented by that string is fetched for the appropriate context.
+     *
+     * If the first argument is an array, then it will be treated as an array
+     * of dependency string names to fetch. An optional function callback can
+     * be specified to execute when all of those dependencies are available.
+     *
+     * Make a local req variable to help Caja compliance (it assumes things
+     * on a require that are not standardized), and to give a short
+     * name for minification/local scope use.
+     */
+    req = requirejs = function requirejs(deps, callback, errback, optional) {
+      var contextOptions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+      // Find the right context, use default
+      var context;
+      var config;
+      var contextName = defContextName;
+
+      // Determine if have config object in the call.
+      if (!isArray(deps) && typeof deps !== 'string') {
+        // deps is a config object
+        config = deps;
+        if (isArray(callback)) {
+          // Adjust args if there are dependencies
+          deps = callback;
+          callback = errback;
+          errback = optional;
+        } else {
+          deps = [];
+        }
+      }
+      if (config && config.context) {
+        contextName = config.context;
+      }
+      if (contextOptions.name) {
+        contextName = contextOptions.name;
+      }
+      context = getOwn(contexts, contextName);
+      if (!context) {
+        context = contexts[contextName] = req.s.newContext(contextName, contextOptions);
+      }
+      if (config) {
+        context.configure(config);
+      }
+      return context.require(deps, callback, errback);
+    };
+
+    /**
+     * Support require.config() to make it easier to cooperate with other
+     * AMD loaders on globally agreed names.
+     */
+    req.config = function (config) {
+      return req(config);
+    };
+
+    /**
+     * Execute something after the current tick
+     * of the event loop. Override for other envs
+     * that have a better solution than setTimeout.
+     * @param  {Function} fn function to execute later.
+     */
+    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
+      setTimeout(fn, 4);
+    } : function (fn) {
+      fn();
+    };
+
+    /**
+     * Export require as a global, but only if it does not already exist.
+     */
+    if (!require) {
+      require = req;
+    }
+    req.version = version;
+
+    // Used to filter out dependencies that are already paths.
+    req.jsExtRegExp = /^\/|:|\?|\.js$|\.css$/;
+    req.isBrowser = isBrowser;
+    s = req.s = {
+      contexts: contexts,
+      newContext: newContext
+    };
+
+    // Create default context.
+    req({});
+
+    // Exports some context-sensitive methods on global require.
+    each(['toUrl', 'undef', 'defined', 'specified'], function (prop) {
+      // Reference from contexts instead of early binding to default context,
+      // so that during builds, the latest instance of the default context
+      // with its config gets used.
+      req[prop] = function () {
+        var ctx = contexts[defContextName];
+        return ctx.require[prop].apply(ctx, arguments);
+      };
+    });
+    if (isBrowser) {
+      head = s.head = document.getElementsByTagName('head')[0];
+      body = s.body = document.getElementsByTagName('body')[0];
+      // If BASE tag is in play, using appendChild is a problem for IE6.
+      // When that browser dies, this can be removed. Details in this jQuery bug:
+      // http://dev.jquery.com/ticket/2709
+      baseElement = document.getElementsByTagName('base')[0];
+      if (baseElement) {
+        head = s.head = baseElement.parentNode;
+      }
+    }
+
+    /**
+     * Any errors that require explicitly generates will be passed to this
+     * function. Intercept/override it if you want custom error handling.
+     * @param {Error} err the error object.
+     */
+    req.onError = defaultOnError;
+
+    /**
+     * Creates the node for the load command. Only used in browser envs.
+     */
+    req.createNode = function (config, moduleName, url) {
+      // get type css
+      var type = '';
+      try {
+        var urls = url.split('?');
+        if (urls[0].endsWith('.css')) type = 'css';
+      } catch (error) {}
+      if (type === 'css') {
+        // css
+        var node = config.xhtml ? document.createElementNS('http://www.w3.org/1999/xhtml', 'html:link') : document.createElement('link');
+        node.href = url;
+        node.rel = 'stylesheet';
+        node.type = config.linkType || 'text/css';
+        return node;
+      } else {
+        var node = config.xhtml ? document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') : document.createElement('script');
+        node.type = config.scriptType || 'text/javascript';
+        node.charset = 'utf-8';
+        node.async = false;
+        return node;
+      }
+    };
+
+    /**
+     * Does the request to load a module for the browser case.
+     * Make this a separate function to allow other environments
+     * to override it.
+     *
+     * @param {Object} context the require context to find state.
+     * @param {String} moduleName the name of the module.
+     * @param {Object} url the URL to the module.
+     */
+    req.load = function (context, moduleName, url) {
+      var config = context && context.config || {};
+      var node;
+      if (isBrowser) {
+        // In the browser so use a script tag
+        node = req.createNode(config, moduleName, url);
+        node.setAttribute('data-requirecontext', context.contextName);
+        node.setAttribute('data-requiremodule', moduleName);
+
+        // Set up load listener. Test attachEvent first because IE9 has
+        // a subtle issue in its addEventListener and script onload firings
+        // that do not match the behavior of all other browsers with
+        // addEventListener support, which fire the onload event for a
+        // script right after the script execution. See:
+        // https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
+        // UNFORTUNATELY Opera implements attachEvent but does not follow the script
+        // script execution mode.
+        if (node.attachEvent &&
+        // Check if node.attachEvent is artificially added by custom script or
+        // natively supported by browser
+        // read https://github.com/requirejs/requirejs/issues/187
+        // if we can NOT find [native code] then it must NOT natively supported.
+        // in IE8, node.attachEvent does not have toString()
+        // Note the test for "[native code" with no closing brace, see:
+        // https://github.com/requirejs/requirejs/issues/273
+        !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) && !isOpera) {
+          // Probably IE. IE (at least 6-8) do not fire
+          // script onload right after executing the script, so
+          // we cannot tie the anonymous define call to a name.
+          // However, IE reports the script as being in 'interactive'
+          // readyState at the time of the define call.
+          useInteractive = true;
+          node.attachEvent('onreadystatechange', context.onScriptLoad);
+          // It would be great to add an error handler here to catch
+          // 404s in IE9+. However, onreadystatechange will fire before
+          // the error handler, so that does not help. If addEventListener
+          // is used, then IE will fire error before load, but we cannot
+          // use that pathway given the connect.microsoft.com issue
+          // mentioned above about not doing the 'script execute,
+          // then fire the script load event listener before execute
+          // next script' that other browsers do.
+          // Best hope: IE10 fixes the issues,
+          // and then destroys all installs of IE 6-9.
+          // node.attachEvent('onerror', context.onScriptError);
+        } else {
+          node.addEventListener('load', context.onScriptLoad, false);
+          node.addEventListener('error', context.onScriptError, false);
+        }
+        node.src = url;
+
+        // Calling onNodeCreated after all properties on the node have been
+        // set, but before it is placed in the DOM.
+        if (config.onNodeCreated) {
+          config.onNodeCreated(node, config, moduleName, url);
+        }
+
+        // For some cache cases in IE 6-8, the script executes before the end
+        // of the appendChild execution, so to tie an anonymous define
+        // call to the module name (which is stored on the node), hold on
+        // to a reference to this node, but clear after the DOM insertion.
+        currentlyAddingScript = node;
+        if (baseElement) {
+          head.insertBefore(node, baseElement);
+        } else {
+          // 微前端-阿里qiankun没有document.currentScript，webpack5生成异步chunk的访问地址404问题
+          if (body) {
+            body.appendChild(node);
+          } else {
+            head.appendChild(node);
+          }
+        }
+        currentlyAddingScript = null;
+        return node;
+      } else if (isWebWorker) {
+        try {
+          // In a web worker, use importScripts. This is not a very
+          // efficient use of importScripts, importScripts will block until
+          // its script is downloaded and evaluated. However, if web workers
+          // are in play, the expectation is that a build has been done so
+          // that only one script needs to be loaded anyway. This may need
+          // to be reevaluated if other use cases become common.
+
+          // Post a task to the event loop to work around a bug in WebKit
+          // where the worker gets garbage-collected after calling
+          // importScripts(): https://webkit.org/b/153317
+          setTimeout(function () {}, 0);
+          importScripts(url);
+
+          // Account for anonymous modules
+          context.completeLoad(moduleName);
+        } catch (e) {
+          context.onError(makeError('importscripts', 'importScripts failed for ' + moduleName + ' at ' + url, e, [moduleName]));
+        }
+      }
+    };
+    function getInteractiveScript() {
+      if (interactiveScript && interactiveScript.readyState === 'interactive') {
+        return interactiveScript;
+      }
+      eachReverse(scripts(), function (script) {
+        if (script.readyState === 'interactive') {
+          return interactiveScript = script;
+        }
+      });
+      return interactiveScript;
+    }
+
+    // Look for a data-main script attribute, which could also adjust the baseUrl.
+    if (isBrowser && !cfg.skipDataMain) {
+      // Figure out baseUrl. Get it from the script tag with require.js in it.
+      eachReverse(scripts(), function (script) {
+        // Set the 'head' where we can append children by
+        // using the script's parent.
+        if (!head) {
+          head = script.parentNode;
+        }
+
+        // Look for a data-main attribute to set main script for the page
+        // to load. If it is there, the path to data main becomes the
+        // baseUrl, if it is not already set.
+        dataMain = script.getAttribute('data-main');
+        if (dataMain) {
+          // Preserve dataMain in case it is a path (i.e. contains '?')
+          mainScript = dataMain;
+
+          // Set final baseUrl if there is not already an explicit one,
+          // but only do so if the data-main value is not a loader plugin
+          // module ID.
+          if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
+            // Pull off the directory of data-main for use as the
+            // baseUrl.
+            src = mainScript.split('/');
+            mainScript = src.pop();
+            subPath = src.length ? src.join('/') + '/' : './';
+            cfg.baseUrl = subPath;
+          }
+
+          // Strip off any trailing .js since mainScript is now
+          // like a module name.
+          mainScript = mainScript.replace(jsSuffixRegExp, '');
+
+          // If mainScript is still a path, fall back to dataMain
+          if (req.jsExtRegExp.test(mainScript)) {
+            mainScript = dataMain;
+          }
+
+          // Put the data-main script in the files to load.
+          cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
+          return true;
+        }
+      });
+    }
+
+    /**
+     * The function that handles definitions of modules. Differs from
+     * require() in that a string for the module should be the first argument,
+     * and the function to execute after dependencies are loaded should
+     * return a value to define the module corresponding to the first argument's
+     * name.
+     */
+    define = function define(name, deps, callback) {
+      var node, context;
+
+      // Allow for anonymous modules
+      if (typeof name !== 'string') {
+        // Adjust args appropriately
+        callback = deps;
+        deps = name;
+        name = null;
+      }
+
+      // This module may not have dependencies
+      if (!isArray(deps)) {
+        callback = deps;
+        deps = null;
+      }
+
+      // If no name, and callback is a function, then figure out if it a
+      // CommonJS thing with dependencies.
+      if (!deps && isFunction(callback)) {
+        deps = [];
+        // Remove comments from the callback string,
+        // look for require calls, and pull them into the dependencies,
+        // but only if there are function args.
+        if (callback.length) {
+          callback.toString().replace(commentRegExp, commentReplace).replace(cjsRequireRegExp, function (match, dep) {
+            deps.push(dep);
+          });
+
+          // May be a CommonJS thing even without require calls, but still
+          // could use exports, and module. Avoid doing exports and module
+          // work though if it just needs require.
+          // REQUIRES the function to expect the CommonJS variables in the
+          // order listed below.
+          deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
+        }
+      }
+
+      // If in IE 6-8 and hit an anonymous define() call, do the interactive
+      // work.
+      if (useInteractive) {
+        node = currentlyAddingScript || getInteractiveScript();
+        if (node) {
+          if (!name) {
+            name = node.getAttribute('data-requiremodule');
+          }
+          context = contexts[node.getAttribute('data-requirecontext')];
+        }
+      }
+
+      // Always save off evaluating the def call until the script onload handler.
+      // This allows multiple modules to be in a file without prematurely
+      // tracing dependencies, and allows for anonymous module support,
+      // where the module name is not known until the script onload event
+      // occurs. If no context, use the global queue, and get it processed
+      // in the onscript load callback.
+      if (context) {
+        context.defQueue.push([name, deps, callback]);
+        context.defQueueMap[name] = true;
+      } else {
+        globalDefQueue.push([name, deps, callback]);
+      }
+    };
+    define.amd = {
+      jQuery: true
+    };
+
+    /**
+     * Executes the text. Normally just uses eval, but can be modified
+     * to use a better, environment-specific call. Only used for transpiling
+     * loader plugins, not for plain JS modules.
+     * @param {String} text the text to execute/evaluate.
+     */
+    req.exec = function (text) {
+      /* jslint evil: true */
+      // eslint-disable-next-line no-eval
+      return eval(text);
+    };
+    __devfab_requirejs.require = require;
+    __devfab_requirejs.define = define;
+    // Set up with config info.
+    req(cfg);
+  })(commonjsGlobal, typeof setTimeout === 'undefined' ? undefined : setTimeout)
+
+  /* ----------------------------------------------------------------------------
+   * 以下为本地适配层，不属于 RequireJS 原始文件内容。
+   * -------------------------------------------------------------------------- */;
+  (function (global) {
+    if (__devfab_requirejs.__requirejsAdapterApplied) {
+      return;
+    }
+    __devfab_requirejs.__requirejsAdapterApplied = true;
+    var rawRequire = __devfab_requirejs.require;
+    var rawDefine = __devfab_requirejs.define;
+    var require = function require(_domain, _deps, _callback, _errback) {
+      var domain = _domain;
+      var deps = _deps;
+      var callback = _callback;
+      var errback = _errback;
+      if (Array.isArray(_domain) && typeof _deps === 'function') {
+        deps = _domain;
+        callback = _deps;
+        errback = _callback;
+        rawRequire(deps, callback, errback);
+        return;
+      }
+      if (!_domain && Array.isArray(deps)) {
+        domain = [];
+      }
+      if (Array.isArray(domain) && Array.isArray(deps)) {
+        domain = domain.join('/');
+      }
+      var newdeps = domain ? [] : deps;
+      if (typeof domain === 'string' && domain && Array.isArray(deps)) {
+        deps.forEach(function (item) {
+          newdeps.push("".concat(domain).concat(item.substr(0, 1) === '/' ? '' : '/').concat(item));
+        });
+      }
+      console.debug('[devfab][requirejs]: %c requireInner, Parameter[newdeps] is %o', 'color:fuchsia', newdeps);
+      rawRequire(newdeps, callback, errback);
+    };
+    var define = function define(_domain, _deps, _callback) {
+      var domain = _domain;
+      var deps = _deps;
+      var callback = _callback;
+      if (Array.isArray(_domain) && typeof _deps === 'function') {
+        deps = _domain;
+        callback = _deps;
+        rawDefine(deps, callback);
+        return;
+      }
+      if (!_domain && Array.isArray(deps)) {
+        domain = [];
+      }
+      if (Array.isArray(domain) && Array.isArray(deps)) {
+        domain = domain.join('/');
+      }
+      var newdeps = domain ? [] : deps;
+      if (typeof domain === 'string' && domain && Array.isArray(deps)) {
+        deps.forEach(function (item) {
+          newdeps.push("".concat(domain).concat(item.substr(0, 1) === '/' ? '' : '/').concat(item));
+        });
+      }
+      rawDefine(newdeps, callback);
+    };
+
+    // RequireJS 把 config / undef / defined / specified / onError / toUrl 等 API
+    // 挂在 require 函数本身。包装后若不转发，这些能力会整片消失：
+    // urlArgs 配不上（版本号进不了 URL）、失败模块 undef 不掉（重试必然复用失败状态）、
+    // 已加载状态查不到。这里按自有属性逐个复制，包装函数已有的键不覆盖。
+    for (var prop in rawRequire) {
+      if (Object.prototype.hasOwnProperty.call(rawRequire, prop) && typeof require[prop] === 'undefined') {
+        require[prop] = rawRequire[prop];
+      }
+    }
+    __devfab_requirejs._require = rawRequire;
+    __devfab_requirejs._define = rawDefine;
+    __devfab_requirejs.require = require;
+    __devfab_requirejs.define = define;
+  })();
+
+  /**
+   * 加载策略层：清单登记（manifest）+ 域名白名单 + 版本锁 + 完整性校验。
+   *
+   * 定位：让「运行时加载远端脚本」从**风险**变成**可审计的特性**。
+   * 这一层不做代码隔离（那是沙箱的事），只回答一个问题：这段代码该不该被执行。
+   *
+   * 边界（如实告知宿主，别指望它做它做不到的事）：
+   * - sha256 校验依赖 `fetch` + `crypto.subtle`。AMD 通道拿不到脚本文本（RequireJS
+   *   自己插 <script>），所以 AMD 侧只做「登记制 + 域名白名单 + 版本锁」；
+   *   完整性校验用在 ESM 通道（loadModules）与构建期（scripts/manifest.js）。
+   * - `crypto.subtle` 只在安全上下文（https / localhost）可用，非安全上下文会跳过，
+   *   跳过这件事会体现在返回值的 `skipped` 里，不静默通过。
+   *
+   * ============================================================================
+   * manifest.json 的格式与生成
+   * ============================================================================
+   *
+   * 由 `node scripts/manifest.js <扫描目录>` 在**构建期**产出，随静态资源一起发布。
+   * 不要在运行时生成：让运行时自己扫目录算摘要，等于自己给自己发许可 —— 文件被改后
+   * 重算一遍，清单就跟着变了，登记制当场失效。清单的效力来自「它在文件被修改之前
+   * 就固定下来」。
+   *
+   * 格式只有四个顶层字段，多写不读：
+   *
+   *   {
+   *     "name": "frontend-extends",
+   *     "version": "1.2.0",
+   *     "generatedAt": "2026-10-20T10:44:48.413Z",
+   *     "modules": {
+   *       "extendjs/frontend/frontend_view_list_FE.Extend.js": {
+   *         "sha256": "<64 位十六进制摘要>",
+   *         "size": 733
+   *       }
+   *     }
+   *   }
+   *
+   * 字段消费方：
+   *   - name         -> describe()，只用于日志展示
+   *   - version      -> checkVersion()，版本锁的比对基准，生成时请显式指定
+   *   - generatedAt  -> 无人使用；仅供人工追溯。`--check` **故意不比对**它，
+   *                     否则每次生成都不同，CI 永远红。
+   *   - modules      -> _moduleIndex()，登记制与完整性校验的数据源
+   *
+   * modules 支持两种形态（_moduleIndex 都能吃）：
+   *   - 对象：{ "<模块 id>": { sha256, size } }        <- scripts/manifest.js 的产出
+   *   - 数组：[{ path: "<模块 id>", sha256, size }]     <- 手写或其他工具产出
+   * 条目里的摘要字段名**必须是 sha256**。换成 hash / digest 之类的名字不会报错，
+   * entryOf() 取不到值时走「无期望值」分支，完整性校验会被静默跳过。
+   *
+   * -------------------------- key 必须与模块 id 同形 --------------------------
+   *
+   * key 是相对扫描目录的路径，斜杠分隔，不带前导 `./` 或 `/`：
+   *
+   *   扫描 example/vue3/static  ->  key = extendjs/frontend/xxx_FE.Extend.js
+   *   运行时 require(['extendjs', 'frontend'], ['xxx_FE.Extend.js'])
+   *                            ->  模块 id = extendjs/frontend/xxx_FE.Extend.js   一致
+   *
+   * 这就是 toModuleIds()（运行时）与 manifest.js 的 toKey()（构建期）必须同构的原因。
+   * 扫错层级时 key 会丢掉域前缀，现象是「明明登记了却全部 403」，此时用 --base 补：
+   *
+   *   node scripts/manifest.js example/vue3/static/extendjs --base extendjs
+   *
+   * ----------------------------- 生成命令与参数 -----------------------------
+   *
+   *   node scripts/manifest.js <扫描目录> [选项]
+   *
+   *   --name <包名>      默认取目录名
+   *   --version <版本>   默认 1.0.0；**请始终显式传**，它是版本锁的基准
+   *   --base <前缀>      给 key 加路径前缀，默认空
+   *   --out <文件>       默认 <扫描目录>/manifest.json（放这里宿主才能访问到）
+   *   --check            只校验不写盘，与目录不一致时退出码 1，给 CI 用
+   *
+   * 扫描是递归的，且只收 `.js` / `.mjs`；已有的 manifest.json 会被跳过，不会自我递归。
+   * 除生成外还支持一致性校验，能报出三类差异（清单缺少 / 文件已不存在 / 内容已变更）：
+   *
+   *   node scripts/manifest.js static --name frontend-extends --version 1.2.0 --check
+   *
+   * 接进宿主时注意时序：`configure({ manifest })` 之前发起的加载会按「无 manifest」
+   * 放行，所以清单要在启动早期就绪（构建期 import，或启动时 await fetch）。
+   */
+
+  /** 策略拒绝：未登记、来源不在白名单、版本锁不匹配、完整性校验失败 */
+  var CODE_POLICY = 403;
+
+  /**
+   * 路径归一化。manifest 的 key 与运行时拼出来的模块 id 必须用同一种写法，
+   * 否则「明明登记了却查不到」这类问题极难排查。
+   */
+  function normalizePath(p) {
+    return String(p == null ? '' : p).replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+  }
+  function isAbsoluteUrl(url) {
+    return /^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(url) || /^(?:blob|data):/i.test(url);
+  }
+  function toHex(buffer) {
+    var bytes = new Uint8Array(buffer);
+    var out = '';
+    for (var i = 0; i < bytes.length; i++) {
+      out += bytes[i].toString(16).padStart(2, '0');
+    }
+    return out;
+  }
+  var LoadPolicy = /*#__PURE__*/function () {
+    function LoadPolicy(options) {
+      _classCallCheck(this, LoadPolicy);
+      this.manifest = null;
+      this.origins = null;
+      this.lockVersion = null;
+      this.verifyHash = true;
+      this.fetch = null;
+      this._index = null;
+      this.configure(options);
+    }
+
+    /** 增量配置：只覆盖传进来的字段，未传的保持原值 */
+    return _createClass(LoadPolicy, [{
+      key: "configure",
+      value: function configure(options) {
+        var o = options || {};
+        if (o.manifest !== undefined) this.manifest = o.manifest || null;
+        if (o.origins !== undefined) {
+          this.origins = o.origins ? [].concat(o.origins).map(function (item) {
+            return String(item).trim().replace(/\/+$/, '');
+          }) : null;
+        }
+        if (o.lockVersion !== undefined) this.lockVersion = o.lockVersion || null;
+        if (o.verifyHash !== undefined) this.verifyHash = !!o.verifyHash;
+        if (o.fetch !== undefined) {
+          this.fetch = o.fetch || null;
+        } else if (!this.fetch && typeof fetch === 'function') {
+          this.fetch = function () {
+            return fetch.apply(void 0, arguments);
+          };
+        }
+        this._index = null;
+        return this;
+      }
+    }, {
+      key: "enabled",
+      get: function get() {
+        return !!this.manifest;
+      }
+
+      /* ------------------------------ 清单 ------------------------------ */
+    }, {
+      key: "_moduleIndex",
+      value: function _moduleIndex() {
+        if (this._index) return this._index;
+        var index = {};
+        var modules = this.manifest && this.manifest.modules;
+        if (Array.isArray(modules)) {
+          modules.forEach(function (item) {
+            if (item && item.path) index[normalizePath(item.path)] = item;
+          });
+        } else if (modules && _typeof(modules) === 'object') {
+          Object.keys(modules).forEach(function (key) {
+            index[normalizePath(key)] = modules[key] || {};
+          });
+        }
+        this._index = index;
+        return index;
+      }
+    }, {
+      key: "entryOf",
+      value: function entryOf(moduleId) {
+        if (!this.manifest) return null;
+        return this._moduleIndex()[normalizePath(moduleId)] || null;
+      }
+
+      /** 版本锁：宿主钉死某个清单版本，防止「悄悄换了文件」 */
+    }, {
+      key: "checkVersion",
+      value: function checkVersion() {
+        if (!this.lockVersion || !this.manifest) return null;
+        var actual = String(this.manifest.version || '');
+        if (actual === String(this.lockVersion)) return null;
+        return {
+          code: CODE_POLICY,
+          message: "\u6E05\u5355\u7248\u672C ".concat(actual || '(未声明)', " \u4E0E\u9501\u5B9A\u7248\u672C ").concat(this.lockVersion, " \u4E0D\u4E00\u81F4\uFF0C\u62D2\u7EDD\u52A0\u8F7D")
+        };
+      }
+
+      /**
+       * 批量校验一组模块 id。
+       * - 未配置 manifest：登记制不启用，直接放行（保持对存量宿主的零影响）；
+       * - 配置了 manifest：不在清单里的一律拒，这是「只能跑经过打包的产物」的落点。
+       */
+    }, {
+      key: "checkModules",
+      value: function checkModules(moduleIds) {
+        var versionDenied = this.checkVersion();
+        if (versionDenied) return versionDenied;
+        if (!this.manifest) return null;
+        for (var i = 0; i < moduleIds.length; i++) {
+          var id = normalizePath(moduleIds[i]);
+          if (!this._moduleIndex()[id]) {
+            return {
+              code: CODE_POLICY,
+              message: "Module ".concat(id, " not registered in the list, loading denied.")
+            };
+          }
+        }
+        return null;
+      }
+
+      /* ---------------------------- 白名单 ---------------------------- */
+    }, {
+      key: "checkOrigin",
+      value: function checkOrigin(url) {
+        if (!this.origins) return null;
+        // 相对路径必然同源，不参与白名单判断
+        if (!isAbsoluteUrl(url)) return null;
+        var origin;
+        try {
+          origin = new URL(url).origin;
+        } catch (err) {
+          return {
+            code: CODE_POLICY,
+            message: "\u65E0\u6CD5\u89E3\u6790\u7684\u5730\u5740\uFF1A".concat(url)
+          };
+        }
+        if (this.origins.indexOf(origin) === -1) {
+          return {
+            code: CODE_POLICY,
+            message: "\u6765\u6E90 ".concat(origin, " \u4E0D\u5728\u767D\u540D\u5355\u5185\uFF08\u5141\u8BB8\uFF1A").concat(this.origins.join(', '), "\uFF09")
+          };
+        }
+        return null;
+      }
+
+      /* ---------------------------- 完整性 ---------------------------- */
+
+      /**
+       * 预检 sha256：fetch 取文本算摘要，通过后调用方再真正加载。
+       * 代价是多一次请求（浏览器缓存通常能命中），换来「文件被替换」能当场发现。
+       */
+    }, {
+      key: "verify",
+      value: function verify(url, expected) {
+        var _this = this;
+        if (!this.verifyHash) return Promise.resolve({
+          ok: true,
+          skipped: 'disabled'
+        });
+        if (!expected) return Promise.resolve({
+          ok: true
+        });
+        var subtle = typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.subtle;
+        if (!subtle) return Promise.resolve({
+          ok: true,
+          skipped: 'crypto.subtle unavailable（需要 https / localhost）'
+        });
+        if (!this.fetch) return Promise.resolve({
+          ok: true,
+          skipped: 'fetch unavailable'
+        });
+        return Promise.resolve().then(function () {
+          return _this.fetch(url);
+        }).then(function (res) {
+          if (!res || !res.ok) {
+            return {
+              ok: false,
+              message: "\u5B8C\u6574\u6027\u9884\u68C0\u8BF7\u6C42\u5931\u8D25\uFF1AHTTP ".concat(res && res.status || 'unknown')
+            };
+          }
+          return res.arrayBuffer().then(function (buffer) {
+            return subtle.digest('SHA-256', buffer);
+          });
+        }).then(function (digest) {
+          if (!digest || digest.ok === false) return digest;
+          var actual = toHex(digest);
+          var want = String(expected).toLowerCase();
+          if (actual !== want) {
+            return {
+              ok: false,
+              message: "sha256 \u4E0D\u5339\u914D\uFF1A\u671F\u671B ".concat(want, "\uFF0C\u5B9E\u9645 ").concat(actual)
+            };
+          }
+          return {
+            ok: true
+          };
+        })["catch"](function (err) {
+          return {
+            ok: false,
+            message: "\u5B8C\u6574\u6027\u9884\u68C0\u5F02\u5E38\uFF1A".concat(err && err.message || err),
+            error: err
+          };
+        });
+      }
+
+      /** 策略摘要：宿主启动时打一行日志，比事后翻代码有用 */
+    }, {
+      key: "describe",
+      value: function describe() {
+        return {
+          manifest: this.enabled ? this.manifest.name || '(unnamed)' : null,
+          version: this.manifest && this.manifest.version || null,
+          lockVersion: this.lockVersion,
+          modules: this.enabled ? Object.keys(this._moduleIndex()).length : 0,
+          origins: this.origins ? this.origins.slice() : null,
+          verifyHash: this.verifyHash
+        };
+      }
+    }]);
+  }();
+
+  /**
+   * 全局污染检测：加载前后 diff window 的 key 集合。
+   *
+   * 为什么需要：二开脚本直接跑在宿主 window 上，A 客户的脚本改了一个全局变量，
+   * B 客户就跟着崩，而且现场无法归因。真做 iframe / Proxy 沙箱成本极高，
+   * 但「加载完能告诉你动了哪些全局」只需要几十行，能挡住大半这类事故。
+   *
+   * 边界（这是观测，不是隔离）：
+   * - 事后告警，不阻止副作用——脚本已经执行过了；
+   * - 并发加载时窗口会重叠，归因以「最后完成的一批」结算，可能不准；
+   * - 只比较可枚举自有属性的**引用**，`window.foo.bar = 1` 这类深层改动检测不到。
+   */
+
+  /** 默认盯防的 key：出现即说明宿主的关键设施被动过 */
+  var DEFAULT_WATCH = ['$', 'jQuery', 'define', 'require', 'requirejs', 'devfab', '__devfab', '__devfab_requirejs'];
+  var GlobalGuard = /*#__PURE__*/function () {
+    function GlobalGuard(options) {
+      _classCallCheck(this, GlobalGuard);
+      var o = options || {};
+      this.maxPollution = o.maxPollution === undefined ? 3 : Number(o.maxPollution);
+      this.watch = [].concat(o.watch || DEFAULT_WATCH);
+      this.target = o.target || (typeof window !== 'undefined' ? window : null);
+      this.enabled = o.enabled === undefined ? true : !!o.enabled;
+      this._pending = 0;
+      this._before = null;
+      this.lastWarnings = [];
+    }
+    return _createClass(GlobalGuard, [{
+      key: "_snapshot",
+      value: function _snapshot() {
+        var map = new Map();
+        var target = this.target;
+        if (!target) return map;
+        Object.keys(target).forEach(function (key) {
+          map.set(key, target[key]);
+        });
+        return map;
+      }
+    }, {
+      key: "_diff",
+      value: function _diff() {
+        var _this = this;
+        var before = this._before;
+        var after = this._snapshot();
+        var warnings = [];
+        if (!before) return warnings;
+        after.forEach(function (value, key) {
+          var watched = _this.watch.indexOf(key) !== -1;
+          if (!before.has(key)) {
+            warnings.push({
+              type: 'added',
+              key: key,
+              watched: watched
+            });
+            return;
+          }
+          if (before.get(key) !== value) {
+            warnings.push({
+              type: 'overwritten',
+              key: key,
+              watched: watched
+            });
+          }
+        });
+        // 命中盯防名单，或新增数量超过阈值，才认为「值得提醒」。
+        // 1~2 个自有全局是正常写法，全报会把信号淹掉。
+        var watchedCount = warnings.filter(function (item) {
+          return item.watched;
+        }).length;
+        var addedCount = warnings.filter(function (item) {
+          return item.type === 'added';
+        }).length;
+        if (!watchedCount && addedCount <= this.maxPollution) return [];
+        return warnings;
+      }
+
+      /**
+       * 开始观测。返回的 `end()` 幂等，重复调用只有第一次有效，
+       * 这样超时分支和 errback 分支可以都调，不会把计数搞负。
+       */
+    }, {
+      key: "begin",
+      value: function begin() {
+        var _this2 = this;
+        if (!this.enabled || !this.target) {
+          return {
+            end: function end() {
+              return [];
+            }
+          };
+        }
+        this._pending++;
+        if (this._pending === 1) this._before = this._snapshot();
+        var done = false;
+        return {
+          end: function end() {
+            if (done) return [];
+            done = true;
+            _this2._pending--;
+            // 还有并发批次没结束，交给最后结束的那一批结算
+            if (_this2._pending > 0) return [];
+            var warnings = _this2._diff();
+            _this2._before = null;
+            _this2.lastWarnings = warnings;
+            return warnings;
+          }
+        };
+      }
+    }, {
+      key: "configure",
+      value: function configure(options) {
+        var o = options || {};
+        if (o.enabled !== undefined) this.enabled = !!o.enabled;
+        if (o.maxPollution !== undefined) this.maxPollution = Number(o.maxPollution);
+        if (o.watch !== undefined) this.watch = [].concat(o.watch || []);
+        if (o.target !== undefined) this.target = o.target || null;
+        return this;
+      }
+    }]);
+  }();
+
+  /** 加载超时：RequireJS 自己的 waitSeconds 默认 30s，这个定时器是更早的兜底 */
+  var CODE_TIMEOUT = 504;
+
+  /**
+   * 原生动态 import。
+   *
+   * 不能用字面量 `import(url)` —— rollup 在 cjs / umd 输出里会把它改写成
+   * `require(url)`，产物直接失效。用 Function 构造可以绕开静态分析，
+   * 代价是要求 CSP 允许 unsafe-eval（和无 unsafe-eval 就跑不起来的内嵌
+   * RequireJS 是同一个前提，不额外增加约束）。
+   */
+  var nativeImport = null;
+  try {
+    // eslint-disable-next-line no-new-func
+    nativeImport = new Function('s', 'return import(s)');
+  } catch (err) {
+    nativeImport = null;
+  }
+  function parseArgs(_path, _files, _callback, params) {
+    var path = _path;
+    var files = _files;
+    var callback = _callback;
+    // 单参形式：(files, callback) 或 (files)。判据是「第一个是数组、第二个不是数组」，
+    // 放宽到非函数是因为 loadModules([url]) 这种不带回调的调用很常见。
+    if (Array.isArray(_path) && !Array.isArray(_files)) {
+      path = params === null || params === void 0 ? void 0 : params.path;
+      files = _path;
+      callback = typeof _files === 'function' ? _files : _callback;
+    }
+    files = Array.isArray(files) ? files : [];
+    var filesStr = files.join(',');
+    var result = {
+      code: 0,
+      message: '',
+      data: [],
+      warnings: []
+    };
+    if (params.type === 'require' && typeof params.require !== 'function' || params.type === 'define' && typeof params.define !== 'function' //
+    ) {
+      result.code = 404;
+      result.message = "requirejs is undefined, the fiels: ".concat(filesStr);
+    }
+    return {
+      path: path,
+      files: files,
+      callback: callback,
+      filesStr: filesStr,
+      result: result
+    };
+  }
+
+  /**
+   * 把「域前缀 + 文件列表」拼成模块 id，必须与 requirejs.js 适配层的拼法保持一致，
+   * 否则策略层的清单查找会全部落空（而且看起来像「清单没打包进去」）。
+   */
+  function toModuleIds(path, files) {
+    var domain = '';
+    if (Array.isArray(path)) {
+      domain = path.filter(Boolean).join('/');
+    } else if (typeof path === 'string') {
+      domain = path.replace(/\/+$/, '');
+    }
+    return files.map(function (file) {
+      var name = String(file).replace(/^\/+/, '');
+      return domain ? "".concat(domain, "/").concat(name) : name;
+    });
+  }
+  function toNumber(value, fallback) {
+    var num = Number(value);
+    return Number.isFinite(num) ? num : fallback;
+  }
+  var DEFAULT_OPTIONS = {
+    version: '',
+    timeout: 15000,
+    retry: 0,
+    strict: false,
+    baseUrl: ''
+  };
+  var BaseFileRequire = /*#__PURE__*/function () {
+    /**
+     * args 同时承担两件事，分区明确：
+     * - 底层加载器覆盖：`define` / `require` / `undef` / `requireConfig` / `importer`
+     * - 加载策略：`version` / `timeout` / `retry` / `strict` / `baseUrl` / `manifest`
+     *   / `origins` / `lockVersion` / `verifyHash` / `pollution` / `watch` / `maxPollution`
+     * 其余一律走 `configure(options)` 在运行时改。
+     */
+    function BaseFileRequire(args) {
+      var _o$__debug, _window$__devfab_requ, _window$__devfab_requ2, _this$__require;
+      _classCallCheck(this, BaseFileRequire);
+      var o = args || {};
+      this.__debug = (_o$__debug = o.__debug) !== null && _o$__debug !== void 0 ? _o$__debug : false;
+      this.__rootPath = undefined;
+      this.__define = o.define || ((_window$__devfab_requ = window.__devfab_requirejs) === null || _window$__devfab_requ === void 0 ? void 0 : _window$__devfab_requ.define);
+      this.__require = o.require || ((_window$__devfab_requ2 = window.__devfab_requirejs) === null || _window$__devfab_requ2 === void 0 ? void 0 : _window$__devfab_requ2.require);
+      this.__undef = o.undef || (typeof ((_this$__require = this.__require) === null || _this$__require === void 0 ? void 0 : _this$__require.undef) === 'function' ? this.__require.undef : null);
+      this.__requireConfig = o.requireConfig || this._pickRequireConfig(this.__require);
+      this.__import = o.importer || null;
+      this._setTimer = o.setTimeout || function (fn, ms) {
+        return setTimeout(fn, ms);
+      };
+      this._clearTimer = o.clearTimeout || function (id) {
+        return clearTimeout(id);
+      };
+      this.options = {
+        version: o.version ? String(o.version) : DEFAULT_OPTIONS.version,
+        timeout: o.timeout === undefined ? DEFAULT_OPTIONS.timeout : Math.max(0, toNumber(o.timeout, 0)),
+        retry: o.retry === undefined ? DEFAULT_OPTIONS.retry : Math.max(0, toNumber(o.retry, 0)),
+        strict: !!o.strict,
+        baseUrl: o.baseUrl || DEFAULT_OPTIONS.baseUrl
+      };
+      this.policy = new LoadPolicy(o);
+      this.guard = new GlobalGuard(this._guardOptions(o));
+      if (this.options.version) this._applyUrlArgs();
+    }
+
+    /**
+     * urlArgs 只能配在真正在用的那个 require 上。
+     * 传了自定义加载器（stub / 多 context）就取它的 config，否则取内嵌 RequireJS 的。
+     */
+    return _createClass(BaseFileRequire, [{
+      key: "_pickRequireConfig",
+      value: function _pickRequireConfig(loader) {
+        var _window$__devfab_requ3;
+        var req = loader && typeof loader.config === 'function' ? loader : (_window$__devfab_requ3 = window.__devfab_requirejs) === null || _window$__devfab_requ3 === void 0 ? void 0 : _window$__devfab_requ3.require;
+        return req && typeof req.config === 'function' ? req.config.bind(req) : null;
+      }
+    }, {
+      key: "_guardOptions",
+      value: function _guardOptions(o) {
+        if (o.pollution === false) {
+          return {
+            enabled: false,
+            target: o.target
+          };
+        }
+        if (o.pollution && _typeof(o.pollution) === 'object') {
+          return Object.assign({
+            target: o.target
+          }, o.pollution);
+        }
+        return {
+          target: o.target,
+          watch: o.watch,
+          maxPollution: o.maxPollution,
+          enabled: o.pollution === undefined ? true : !!o.pollution
+        };
+      }
+
+      /* ------------------------------ 配置 ------------------------------ */
+
+      /** 运行时增量配置（宿主切版本、换清单、改重试次数都走这里）
+       *  加载策略：版本、超时、重试、清单、白名单、全局污染检测
+       */
+    }, {
+      key: "configure",
+      value: function configure(options) {
+        var o = options || {};
+        if (o.debug !== undefined) this.__debug = !!o.debug;
+        if (o.version !== undefined) this.setVersion(o.version);
+        if (o.timeout !== undefined) this.options.timeout = Math.max(0, toNumber(o.timeout, this.options.timeout));
+        if (o.retry !== undefined) this.options.retry = Math.max(0, toNumber(o.retry, this.options.retry));
+        if (o.strict !== undefined) this.options.strict = !!o.strict;
+        if (o.baseUrl !== undefined) this.options.baseUrl = o.baseUrl || '';
+        if (o.manifest !== undefined || o.origins !== undefined || o.lockVersion !== undefined || o.verifyHash !== undefined || o.fetch !== undefined) {
+          this.policy.configure(o);
+        }
+        if (o.pollution !== undefined) this.guard.configure(this._guardOptions(o));else if (o.watch !== undefined || o.maxPollution !== undefined || o.target !== undefined) {
+          this.guard.configure(o);
+        }
+        return this;
+      }
+
+      /**
+       * 设置二开包版本，拼成 `?v=` 交给 RequireJS 的 urlArgs。
+       *
+       * 注意这是 RequireJS **context 级**配置，一个页面内以最后一次设置为准 ——
+       * 这与实际情况相符：整个二开包本来就应该同一个版本，分模块各自版本只会让缓存失效
+       * 变成玄学。多实例需要不同版本时请分 iframe。
+       */
+    }, {
+      key: "setVersion",
+      value: function setVersion(version) {
+        this.options.version = version ? String(version) : '';
+        this._applyUrlArgs();
+        return this;
+      }
+    }, {
+      key: "_applyUrlArgs",
+      value: function _applyUrlArgs() {
+        if (typeof this.__requireConfig !== 'function') {
+          return false;
+        }
+        try {
+          this.__requireConfig({
+            urlArgs: this.options.version ? "v=".concat(encodeURIComponent(this.options.version)) : ''
+          });
+          return true;
+        } catch (err) {
+          return false;
+        }
+      }
+    }, {
+      key: "getVersion",
+      value: function getVersion() {
+        return this.options.version;
+      }
+
+      /**
+       * 导出本实例的配置快照，供 `create()` 派生新实例时继承。
+       *
+       * 为什么需要：`create()` 原先是彻底干净的实例，于是宿主在单例上
+       * `configure({ manifest, lockVersion })` 之后，`_utils/models/_extend.js` 里那句
+       * `FileRequire.create({ require }).require(...)` 完全不受约束 —— 扩展脚本主链路上
+       * 登记制与版本锁等于没开。派生时继承配置，这个缺口才闭合。
+       *
+       * 刻意**不包含加载器**（`define` / `require` / `undef` / `requireConfig` / `importer`）：
+       * 构造函数会按当前 `window.__devfab_requirejs` 重新取，派生实例拿到的是「此刻真正
+       * 在用的那个加载器」，而不是父实例构造时捕获的旧引用。要指定加载器请显式传，
+       * `create({ require })` 会覆盖。
+       */
+    }, {
+      key: "_snapshotConfig",
+      value: function _snapshotConfig() {
+        return {
+          __debug: this.__debug,
+          version: this.options.version,
+          timeout: this.options.timeout,
+          retry: this.options.retry,
+          strict: this.options.strict,
+          baseUrl: this.options.baseUrl,
+          manifest: this.policy.manifest,
+          origins: this.policy.origins,
+          lockVersion: this.policy.lockVersion,
+          verifyHash: this.policy.verifyHash,
+          fetch: this.policy.fetch,
+          pollution: this.guard.enabled,
+          watch: this.guard.watch,
+          maxPollution: this.guard.maxPollution,
+          target: this.guard.target
+        };
+      }
+
+      /** 策略 + 兜底配置摘要，宿主启动时打一行日志排查效率最高 */
+    }, {
+      key: "describe",
+      value: function describe() {
+        return Object.assign({}, this.options, {
+          debug: this.__debug,
+          policy: this.policy.describe(),
+          pollutionGuard: this.guard.enabled,
+          canUndef: typeof this.__undef === 'function',
+          canNativeImport: typeof (this.__import || nativeImport) === 'function'
+        });
+      }
+
+      /* --------------------------- AMD 通道 --------------------------- */
+    }, {
+      key: "_define",
+      value: function _define(_path, _files, _callback) {
+        var params = {
+          path: this.__rootPath,
+          define: this.__define,
+          type: 'define'
+        };
+        var _parseArgs = parseArgs(_path, _files, _callback, params),
+          path = _parseArgs.path,
+          files = _parseArgs.files,
+          callback = _parseArgs.callback,
+          result = _parseArgs.result;
+        if (result.code === 404) {
+          callback === null || callback === void 0 || callback(result);
+          return;
+        }
+        this.__define(path, files, callback);
+      }
+    }, {
+      key: "_mergeWarnings",
+      value: function _mergeWarnings(prev, next) {
+        var list = (prev || []).slice();
+        (next || []).forEach(function (item) {
+          var exists = list.some(function (one) {
+            return one.type === item.type && one.key === item.key;
+          });
+          if (!exists) list.push(item);
+        });
+        return list;
+      }
+    }, {
+      key: "_undefModules",
+      value: function _undefModules(moduleIds) {
+        var _this = this;
+        if (typeof this.__undef !== 'function') return;
+        moduleIds.forEach(function (id) {
+          try {
+            _this.__undef(id);
+          } catch (err) {
+            // undef 只对曾经顶层 require 过的模块有效；抛错说明它还没进注册表，忽略即可
+          }
+        });
+      }
+
+      /**
+       * 统一加载入口：策略校验 -> 观测 -> 计时 / 重试 -> 结算。
+       * 默认配置（version 空、retry 0、timeout 15s）下的行为与原来一致，
+       * 只是多了一个「更早失败」的兜底和 warnings 字段。
+       */
+    }, {
+      key: "_load",
+      value: function _load(_path, _files, _callback) {
+        var _this2 = this;
+        var config = this.options;
+        var params = {
+          path: this.__rootPath,
+          require: this.__require,
+          type: 'require'
+        };
+        var _parseArgs2 = parseArgs(_path, _files, _callback, params),
+          path = _parseArgs2.path,
+          files = _parseArgs2.files,
+          callback = _parseArgs2.callback,
+          result = _parseArgs2.result,
+          filesStr = _parseArgs2.filesStr;
+        if (result.code === 404) {
+          callback === null || callback === void 0 || callback(result);
+          return;
+        }
+        var moduleIds = toModuleIds(path, files);
+        var denied = this.policy.checkModules(moduleIds);
+        if (denied) {
+          result.code = denied.code;
+          result.message = denied.message;
+          callback === null || callback === void 0 || callback(result);
+          return;
+        }
+        var settled = false;
+        var attempt = 0;
+        var timer = null;
+        var scoop = null;
+        var closeScoop = function closeScoop() {
+          if (!scoop) return;
+          result.warnings = _this2._mergeWarnings(result.warnings, scoop.end());
+          scoop = null;
+        };
+        var finish = function finish() {
+          if (settled) return;
+          settled = true;
+          if (timer !== null) {
+            _this2._clearTimer(timer);
+            timer = null;
+          }
+          closeScoop();
+          if (config.strict && result.warnings.length) {
+            result.code = 500;
+            result.message = "Global pollution detection failed\uFF1A".concat(result.warnings.map(function (item) {
+              return "".concat(item.type, ":").concat(item.key);
+            }).join(', '));
+          }
+          callback === null || callback === void 0 || callback(result);
+        };
+        var start = function start() {
+          attempt++;
+          scoop = _this2.guard.begin();
+          if (config.timeout > 0) {
+            timer = _this2._setTimer(function () {
+              if (settled) return;
+              var err = new Error("load timeout after ".concat(config.timeout, "ms: ").concat(filesStr));
+              err.__devfabTimeout = true;
+              retryOrFail(err, "files load timeout after ".concat(config.timeout, "ms, the files: ").concat(filesStr));
+            }, config.timeout);
+          }
+          _this2.__require(path, files, function () {
+            for (var _len = arguments.length, contents = new Array(_len), _key = 0; _key < _len; _key++) {
+              contents[_key] = arguments[_key];
+            }
+            result.data = contents;
+            finish();
+          }, function (err) {
+            retryOrFail(err);
+          });
+        };
+        var retryOrFail = function retryOrFail(err, message) {
+          if (settled) return;
+          if (timer !== null) {
+            _this2._clearTimer(timer);
+            timer = null;
+          }
+          if (attempt <= config.retry) {
+            closeScoop();
+            // 不 undef 就会复用上一次的失败状态，重试形同虚设
+            _this2._undefModules(moduleIds);
+            start();
+            return;
+          }
+          result.code = err && err.__devfabTimeout ? CODE_TIMEOUT : 500;
+          result.message = message || "files load error, the files: ".concat(filesStr);
+          result.error = err;
+          finish();
+        };
+        start();
+      }
+
+      /**
+       * 带兜底的加载：与 `require` 完全等价，保留这个名字是为了让宿主代码读得懂
+       * 「这一处是走完整策略的」。
+       */
+    }, {
+      key: "load",
+      value: function load(path, files, callback) {
+        this._load(path, files, callback);
+      }
+
+      /* --------------------------- ESM 通道 --------------------------- */
+
+      /**
+       * 把模块 id 解析成可 import 的地址。相对路径以 `baseUrl`（缺省为
+       * `document.baseURI`）为基准，这样宿主不用自己拼绝对地址。
+       */
+    }, {
+      key: "resolveUrl",
+      value: function resolveUrl(rel) {
+        var raw = String(rel == null ? '' : rel);
+        if (/^[a-z][a-z0-9+.-]*:/i.test(raw) || /^\/\//.test(raw)) return raw;
+        var base = this.options.baseUrl || (typeof document !== 'undefined' && document.baseURI ? document.baseURI : '');
+        if (!base) return raw;
+        try {
+          return new URL(raw, base).href;
+        } catch (err) {
+          return raw;
+        }
+      }
+    }, {
+      key: "_importOne",
+      value: function _importOne(moduleId) {
+        var _this3 = this;
+        var url = this.resolveUrl(moduleId);
+        var originDenied = this.policy.checkOrigin(url);
+        if (originDenied) {
+          return Promise.resolve({
+            ok: false,
+            code: originDenied.code,
+            message: originDenied.message
+          });
+        }
+        var entry = this.policy.entryOf(moduleId);
+        var expected = entry && entry.sha256;
+        var run = function run() {
+          var importer = _this3.__import || nativeImport;
+          if (typeof importer !== 'function') {
+            return Promise.resolve({
+              ok: false,
+              code: 500,
+              message: 'native import() is unavailable（CSP 是否禁用了 unsafe-eval？）'
+            });
+          }
+          return Promise.resolve().then(function () {
+            return importer(url);
+          }).then(function (module) {
+            return {
+              ok: true,
+              module: module
+            };
+          }, function (err) {
+            return {
+              ok: false,
+              code: 500,
+              message: "module load error: ".concat(url),
+              error: err
+            };
+          });
+        };
+        if (!expected) return run();
+        return this.policy.verify(url, expected).then(function (verified) {
+          if (!verified.ok) {
+            return {
+              ok: false,
+              code: CODE_POLICY,
+              message: "".concat(verified.message, "\uFF08").concat(url, "\uFF09")
+            };
+          }
+          return run();
+        });
+      }
+
+      /**
+       * ESM 通道：用原生 `import()` 加载，与 AMD 通道并存而不是替代它。
+       *
+       * 用途：新宿主（Vite / ESM）不必为了加载二开产物把 AMD 拖进来；
+       * 相对地，这条通道不做 AMD 匿名 define 那套匹配，模块必须是标准 ESM。
+       * 返回 Promise，同时兼容 callback 写法。
+       */
+    }, {
+      key: "loadModules",
+      value: function loadModules(_path, _files, _callback) {
+        var _this4 = this;
+        var params = {
+          path: this.__rootPath,
+          type: 'module'
+        };
+        var _parseArgs3 = parseArgs(_path, _files, _callback, params),
+          path = _parseArgs3.path,
+          files = _parseArgs3.files,
+          callback = _parseArgs3.callback,
+          result = _parseArgs3.result,
+          filesStr = _parseArgs3.filesStr;
+        var moduleIds = toModuleIds(path, files);
+        var settle = function settle(r) {
+          callback === null || callback === void 0 || callback(r);
+          return r;
+        };
+        var denied = this.policy.checkModules(moduleIds);
+        if (denied) {
+          result.code = denied.code;
+          result.message = denied.message;
+          return Promise.resolve(settle(result));
+        }
+        if (!files.length) {
+          return Promise.resolve(settle(result));
+        }
+        var scoop = this.guard.begin();
+        return Promise.all(moduleIds.map(function (id) {
+          return _this4._importOne(id);
+        })).then(function (list) {
+          result.warnings = scoop.end();
+          var failed = list.filter(function (item) {
+            return !item.ok;
+          });
+          if (failed.length) {
+            // 部分成功也不给半份 data：宿主拿半份当完整用比直接失败更糟
+            result.code = failed[0].code || 500;
+            result.message = "".concat(failed.map(function (item) {
+              return item.message;
+            }).join('; '), "\uFF08the files: ").concat(filesStr, "\uFF09");
+            result.error = failed[0].error;
+          } else {
+            result.data = list.map(function (item) {
+              return item.module;
+            });
+          }
+          return settle(result);
+        });
+      }
+    }, {
+      key: "loadModule",
+      value: function loadModule(url, callback) {
+        return this.loadModules([url], callback);
+      }
+    }]);
+  }();
+  var FileRequireClass = /*#__PURE__*/function (_BaseFileRequire) {
+    function FileRequireClass() {
+      _classCallCheck(this, FileRequireClass);
+      return _callSuper(this, FileRequireClass, arguments);
+    }
+    _inherits(FileRequireClass, _BaseFileRequire);
+    return _createClass(FileRequireClass, [{
+      key: "define",
+      value: function define(path, files, callback) {
+        this._define(path, files, callback);
+      }
+    }, {
+      key: "defineScript",
+      value: function defineScript(o) {
+        this.provideScript(o);
+      }
+    }, {
+      key: "provideScript",
+      value: function provideScript(o) {
+        var callback = o;
+        if (typeof o !== 'function') {
+          callback = function callback() {
+            return o;
+          };
+        }
+        this.define([], callback);
+      }
+    }, {
+      key: "require",
+      value: function require(path, files, callback) {
+        this._load(path, files, callback);
+      }
+    }, {
+      key: "injectScript",
+      value: function injectScript(_path, _files, _callback, _error) {
+        var self = this;
+        var path = _path;
+        var files = _files;
+        var callback = _callback;
+        var error = _error;
+        if (Array.isArray(_path) && typeof _files === 'function') {
+          path = undefined;
+          files = _path;
+          callback = _files;
+          error = _callback;
+        }
+        function onCallback(result) {
+          if (result.code == 0 && Array.isArray(result.data)) {
+            for (var i = 0, len = result.data.length; i < len; i++) {
+              var _callback2;
+              var content = result.data[i];
+              (_callback2 = callback) === null || _callback2 === void 0 || _callback2(content, i);
+            }
+          } else {
+            if (typeof error === 'function') {
+              error(result);
+            } else {
+              self.__debug && console.error('[devfab][FileRequire][injectScript] error: ', result);
+            }
+          }
+        }
+        this._load(path, files, onCallback);
+      }
+    }, {
+      key: "requireScript",
+      value: function requireScript(_path, _files, _callback) {
+        this.injectScript(_path, _files, _callback);
+      }
+    }]);
+  }(BaseFileRequire);
+  var FileRequire = new FileRequireClass();
+  FileRequire.create = function (args) {
+    return new FileRequireClass(_objectSpread2(_objectSpread2({}, this._snapshotConfig()), args));
+  };
+
+  window.__devfab = Object.assign({}, window.__devfab);
+  window.__devfab.FileRequire = FileRequire;
+  window.__devfab.filePolicy = {
+    LoadPolicy: LoadPolicy,
+    GlobalGuard: GlobalGuard,
+    CODE_POLICY: CODE_POLICY,
+    CODE_TIMEOUT: CODE_TIMEOUT
+  };
+
+  exports.CODE_POLICY = CODE_POLICY;
+  exports.CODE_TIMEOUT = CODE_TIMEOUT;
+  exports.DEFAULT_WATCH = DEFAULT_WATCH;
+  exports.FileRequire = FileRequire;
+  exports.GlobalGuard = GlobalGuard;
+  exports.LoadPolicy = LoadPolicy;
+  exports["default"] = FileRequire;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));