{"version":3,"sources":["jsdelivr-header.js","/npm/didi@11.0.0/lib/util.js","/npm/didi@11.0.0/lib/annotation.js","/npm/didi@11.0.0/lib/injector.js"],"names":[],"mappings":"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","file":"/npm/didi@11.0.0/dist/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/didi@11.0.0/dist/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","const CLASS_PATTERN = /^class[ {]/;\n\n\n/**\n * @param {function} fn\n *\n * @return {boolean}\n */\nexport function isClass(fn) {\n  return CLASS_PATTERN.test(fn.toString());\n}\n\n/**\n * @param {any} obj\n *\n * @return {boolean}\n */\nexport function isArray(obj) {\n  return Array.isArray(obj);\n}\n\n/**\n * @param {any} obj\n * @param {string} prop\n *\n * @return {boolean}\n */\nexport function hasOwnProp(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}","import {\n  isArray,\n  isClass\n} from './util.js';\n\n/**\n * @typedef {import('./index.js').InjectAnnotated } InjectAnnotated\n */\n\n/**\n * @template T\n *\n * @params {[...string[], T] | ...string[], T} args\n *\n * @return {T & InjectAnnotated}\n */\nexport function annotate(...args) {\n\n  if (args.length === 1 && isArray(args[0])) {\n    args = args[0];\n  }\n\n  args = [ ...args ];\n\n  const fn = args.pop();\n\n  fn.$inject = args;\n\n  return fn;\n}\n\n\n// Current limitations:\n// - can't put into \"function arg\" comments\n// function /* (no parenthesis like this) */ (){}\n// function abc( /* xx (no parenthesis like this) */ a, b) {}\n//\n// Just put the comment before function or inside:\n// /* (((this is fine))) */ function(a, b) {}\n// function abc(a) { /* (((this is fine))) */}\n//\n// - can't reliably auto-annotate constructor; we'll match the\n// first constructor(...) pattern found which may be the one\n// of a nested class, too.\n\nconst CONSTRUCTOR_ARGS = /constructor\\s*[^(]*\\(\\s*([^)]*)\\)/m;\nconst FN_ARGS = /^(?:async\\s+)?(?:function\\s*[^(]*)?(?:\\(\\s*([^)]*)\\)|(\\w+))/m;\nconst FN_ARG = /\\/\\*([^*]*)\\*\\//m;\n\n/**\n * @param {unknown} fn\n *\n * @return {string[]}\n */\nexport function parseAnnotations(fn) {\n\n  if (typeof fn !== 'function') {\n    throw new Error(`Cannot annotate \"${fn}\". Expected a function!`);\n  }\n\n  const match = fn.toString().match(isClass(fn) ? CONSTRUCTOR_ARGS : FN_ARGS);\n\n  // may parse class without constructor\n  if (!match) {\n    return [];\n  }\n\n  const args = match[1] || match[2];\n\n  return args && args.split(',').map(arg => {\n    const argMatch = arg.match(FN_ARG);\n    return (argMatch && argMatch[1] || arg).trim();\n  }) || [];\n}","import {\n  parseAnnotations,\n  annotate\n} from './annotation.js';\n\nimport {\n  isArray,\n  hasOwnProp\n} from './util.js';\n\n/**\n * @typedef { import('./index.js').ModuleDeclaration } ModuleDeclaration\n * @typedef { import('./index.js').ModuleDefinition } ModuleDefinition\n * @typedef { import('./index.js').InjectorContext } InjectorContext\n *\n * @typedef { import('./index.js').TypedDeclaration<any, any> } TypedDeclaration\n */\n\n/**\n * Create a new injector with the given modules.\n *\n * @param {ModuleDefinition[]} modules\n * @param {InjectorContext} [_parent]\n */\nexport default function Injector(modules, _parent) {\n\n  const parent = _parent || /** @type InjectorContext */ ({\n    get: function(name, strict) {\n      currentlyResolving.push(name);\n\n      if (strict === false) {\n        return null;\n      } else {\n        throw error(`No provider for \"${ name }\"!`);\n      }\n    }\n  });\n\n  const currentlyResolving = [];\n  const providers = this._providers = Object.create(parent._providers || null);\n  const instances = this._instances = Object.create(null);\n\n  const self = instances.injector = this;\n\n  const error = function(msg) {\n    const stack = currentlyResolving.join(' -> ');\n    currentlyResolving.length = 0;\n    return new Error(stack ? `${ msg } (Resolving: ${ stack })` : msg);\n  };\n\n  /**\n   * Return a named service.\n   *\n   * @param {string} name\n   * @param {boolean} [strict=true] if false, resolve missing services to null\n   *\n   * @return {any}\n   */\n  function get(name, strict) {\n    if (!providers[name] && name.includes('.')) {\n\n      const parts = name.split('.');\n      let pivot = get(/** @type { string } */ (parts.shift()));\n\n      while (parts.length) {\n        pivot = pivot[/** @type { string } */ (parts.shift())];\n      }\n\n      return pivot;\n    }\n\n    if (hasOwnProp(instances, name)) {\n      return instances[name];\n    }\n\n    if (hasOwnProp(providers, name)) {\n      if (currentlyResolving.indexOf(name) !== -1) {\n        currentlyResolving.push(name);\n        throw error('Cannot resolve circular dependency!');\n      }\n\n      currentlyResolving.push(name);\n      instances[name] = providers[name][0](providers[name][1]);\n      currentlyResolving.pop();\n\n      return instances[name];\n    }\n\n    return parent.get(name, strict);\n  }\n\n  function fnDef(fn, locals) {\n\n    if (typeof locals === 'undefined') {\n      locals = {};\n    }\n\n    if (typeof fn !== 'function') {\n      if (isArray(fn)) {\n        fn = annotate(fn.slice());\n      } else {\n        throw error(`Cannot invoke \"${ fn }\". Expected a function!`);\n      }\n    }\n\n    /**\n     * @type {string[]}\n     */\n    const inject = fn.$inject || parseAnnotations(fn);\n    const dependencies = inject.map(dep => {\n      if (hasOwnProp(locals, dep)) {\n        return locals[dep];\n      } else {\n        return get(dep);\n      }\n    });\n\n    return {\n      fn: fn,\n      dependencies\n    };\n  }\n\n  /**\n   * Instantiate the given type, injecting dependencies.\n   *\n   * @template T\n   *\n   * @param { Function | [...string[], Function ]} type\n   *\n   * @return T\n   */\n  function instantiate(type) {\n    const {\n      fn,\n      dependencies\n    } = fnDef(type);\n\n    // instantiate var args constructor\n    const Constructor = Function.prototype.bind.call(fn, null, ...dependencies);\n\n    return new Constructor();\n  }\n\n  /**\n   * Invoke the given function, injecting dependencies. Return the result.\n   *\n   * @template T\n   *\n   * @param { Function | [...string[], Function ]} func\n   * @param { Object } [context]\n   * @param { Object } [locals]\n   *\n   * @return {T} invocation result\n   */\n  function invoke(func, context, locals) {\n    const {\n      fn,\n      dependencies\n    } = fnDef(func, locals);\n\n    return fn.apply(context, dependencies);\n  }\n\n  /**\n   * @param {Injector} childInjector\n   *\n   * @return {Function}\n   */\n  function createPrivateInjectorFactory(childInjector) {\n    return annotate(key => childInjector.get(key));\n  }\n\n  /**\n   * @param {ModuleDefinition[]} modules\n   * @param {string[]} [forceNewInstances]\n   *\n   * @return {Injector}\n   */\n  function createChild(modules, forceNewInstances) {\n    if (forceNewInstances && forceNewInstances.length) {\n      const fromParentModule = Object.create(null);\n      const matchedScopes = Object.create(null);\n\n      const privateInjectorsCache = [];\n      const privateChildInjectors = [];\n      const privateChildFactories = [];\n\n      let provider;\n      let cacheIdx;\n      let privateChildInjector;\n      let privateChildInjectorFactory;\n\n      for (let name in providers) {\n        provider = providers[name];\n\n        if (forceNewInstances.indexOf(name) !== -1) {\n          if (provider[2] === 'private') {\n            cacheIdx = privateInjectorsCache.indexOf(provider[3]);\n            if (cacheIdx === -1) {\n              privateChildInjector = provider[3].createChild([], forceNewInstances);\n              privateChildInjectorFactory = createPrivateInjectorFactory(privateChildInjector);\n              privateInjectorsCache.push(provider[3]);\n              privateChildInjectors.push(privateChildInjector);\n              privateChildFactories.push(privateChildInjectorFactory);\n              fromParentModule[name] = [ privateChildInjectorFactory, name, 'private', privateChildInjector ];\n            } else {\n              fromParentModule[name] = [ privateChildFactories[cacheIdx], name, 'private', privateChildInjectors[cacheIdx] ];\n            }\n          } else {\n            fromParentModule[name] = [ provider[2], provider[1] ];\n          }\n          matchedScopes[name] = true;\n        }\n\n        if ((provider[2] === 'factory' || provider[2] === 'type') && provider[1].$scope) {\n          /* jshint -W083 */\n          forceNewInstances.forEach(scope => {\n            if (provider[1].$scope.indexOf(scope) !== -1) {\n              fromParentModule[name] = [ provider[2], provider[1] ];\n              matchedScopes[scope] = true;\n            }\n          });\n        }\n      }\n\n      forceNewInstances.forEach(scope => {\n        if (!matchedScopes[scope]) {\n          throw new Error('No provider for \"' + scope + '\". Cannot use provider from the parent!');\n        }\n      });\n\n      modules.unshift(fromParentModule);\n    }\n\n    return new Injector(modules, self);\n  }\n\n  const factoryMap = {\n    factory: invoke,\n    type: instantiate,\n    value: function(value) {\n      return value;\n    }\n  };\n\n  /**\n   * @param {ModuleDefinition} moduleDefinition\n   * @param {Injector} injector\n   */\n  function createInitializer(moduleDefinition, injector) {\n\n    const initializers = moduleDefinition.__init__ || [];\n\n    return function() {\n      initializers.forEach(initializer => {\n\n        // eagerly resolve component (fn or string)\n        if (typeof initializer === 'string') {\n          injector.get(initializer);\n        } else {\n          injector.invoke(initializer);\n        }\n      });\n    };\n  }\n\n  /**\n   * @param {ModuleDefinition} moduleDefinition\n   */\n  function loadModule(moduleDefinition) {\n\n    const moduleExports = moduleDefinition.__exports__;\n\n    // private module\n    if (moduleExports) {\n      const nestedModules = moduleDefinition.__modules__;\n\n      const clonedModule = Object.keys(moduleDefinition).reduce((clonedModule, key) => {\n\n        if (key !== '__exports__' && key !== '__modules__' && key !== '__init__' && key !== '__depends__') {\n          clonedModule[key] = moduleDefinition[key];\n        }\n\n        return clonedModule;\n      }, Object.create(null));\n\n      const childModules = (nestedModules || []).concat(clonedModule);\n\n      const privateInjector = createChild(childModules);\n      const getFromPrivateInjector = annotate(function(key) {\n        return privateInjector.get(key);\n      });\n\n      moduleExports.forEach(function(key) {\n        providers[key] = [ getFromPrivateInjector, key, 'private', privateInjector ];\n      });\n\n      // ensure child injector initializes\n      const initializers = (moduleDefinition.__init__ || []).slice();\n\n      initializers.unshift(function() {\n        privateInjector.init();\n      });\n\n      moduleDefinition = Object.assign({}, moduleDefinition, {\n        __init__: initializers\n      });\n\n      return createInitializer(moduleDefinition, privateInjector);\n    }\n\n    // normal module\n    Object.keys(moduleDefinition).forEach(function(key) {\n\n      if (key === '__init__' || key === '__depends__') {\n        return;\n      }\n\n      const typeDeclaration = /** @type { TypedDeclaration } */ (\n        moduleDefinition[key]\n      );\n\n      if (typeDeclaration[2] === 'private') {\n        providers[key] = typeDeclaration;\n        return;\n      }\n\n      const type = typeDeclaration[0];\n      const value = typeDeclaration[1];\n\n      providers[key] = [ factoryMap[type], arrayUnwrap(type, value), type ];\n    });\n\n    return createInitializer(moduleDefinition, self);\n  }\n\n  /**\n   * @param {ModuleDefinition[]} moduleDefinitions\n   * @param {ModuleDefinition} moduleDefinition\n   *\n   * @return {ModuleDefinition[]}\n   */\n  function resolveDependencies(moduleDefinitions, moduleDefinition) {\n\n    if (moduleDefinitions.indexOf(moduleDefinition) !== -1) {\n      return moduleDefinitions;\n    }\n\n    moduleDefinitions = (moduleDefinition.__depends__ || []).reduce(resolveDependencies, moduleDefinitions);\n\n    if (moduleDefinitions.indexOf(moduleDefinition) !== -1) {\n      return moduleDefinitions;\n    }\n\n    return moduleDefinitions.concat(moduleDefinition);\n  }\n\n  /**\n   * @param {ModuleDefinition[]} moduleDefinitions\n   *\n   * @return { () => void } initializerFn\n   */\n  function bootstrap(moduleDefinitions) {\n\n    const initializers = moduleDefinitions\n      .reduce(resolveDependencies, [])\n      .map(loadModule);\n\n    let initialized = false;\n\n    return function() {\n\n      if (initialized) {\n        return;\n      }\n\n      initialized = true;\n\n      initializers.forEach(initializer => initializer());\n    };\n  }\n\n  // public API\n  this.get = get;\n  this.invoke = invoke;\n  this.instantiate = instantiate;\n  this.createChild = createChild;\n\n  // setup\n  this.init = bootstrap(modules);\n}\n\n\n// helpers ///////////////\n\nfunction arrayUnwrap(type, value) {\n  if (type !== 'value' && isArray(value)) {\n    value = annotate(value.slice());\n  }\n\n  return value;\n}"]}