{
  "version": 3,
  "sources": ["../../src/elements/ak-locale-context/definitions.ts", "../../node_modules/@lit/context/src/lib/context-request-event.ts", "../../node_modules/@lit/context/src/lib/controllers/context-consumer.ts", "../../node_modules/@lit/context/src/lib/decorators/consume.ts", "../../node_modules/@lit/context/src/lib/value-notifier.ts", "../../node_modules/@lit/context/src/lib/controllers/context-provider.ts", "../../src/elements/AuthentikContexts.ts"],
  "sourcesContent": ["import * as _enLocale from \"@goauthentik/locales/en\";\n\nimport type { LocaleModule } from \"@lit/localize\";\nimport { msg } from \"@lit/localize\";\n\nimport { AkLocale, LocaleRow } from \"./types\";\n\nexport const DEFAULT_FALLBACK = \"en\";\n\nconst enLocale: LocaleModule = _enLocale;\n\nexport { enLocale };\n\n// NOTE: This table cannot be made any shorter, despite all the repetition of syntax. Bundlers look\n// for the `await import` string as a *string target* for doing alias substitution, so putting\n// the import in some sort of abstracting function doesn't work. The same is true for the `msg()`\n// function, which `localize` uses to find strings for extraction and translation. Likewise,\n// because this is a file-level table, the `msg()` must be thunked so that they're re-run when\n// the user changes the locale.\n\n// NOTE: The matchers try to conform loosely to [RFC\n// 5646](https://www.rfc-editor.org/rfc/rfc5646.txt), \"Tags for the Identification of Languages.\" In\n// practice, language tags have been seen using both hyphens and underscores, and the Chinese\n// language uses both \"regional\" and \"script\" suffixes. The regexes use the language and any region\n// or script.\n//\n// Chinese locales usually (but not always) use the script rather than region suffix. The default\n// (optional) fallback for Chinese (zh) is \"Chinese (simplified)\", which is why it has that odd\n// regex syntax at the end which means \"match zh as long as it's not followed by a [:word:] token\";\n// Traditional script and the Taiwanese are attempted first, and if neither matches, anything\n// beginning with that generic \"zh\" is mapped to \"Chinese (simplified).\"\n\n// - Code for Lit/Locale\n// - Regex for matching user-supplied locale.\n// - Text Label\n// - Locale loader.\n\n// prettier-ignore\nconst debug: LocaleRow = [\n    \"pseudo-LOCALE\",  /^pseudo/i,  () => msg(\"Pseudolocale (for testing)\"),  async () => await import(\"@goauthentik/locales/pseudo-LOCALE\"),\n];\n\n// prettier-ignore\nconst LOCALE_TABLE: LocaleRow[] = [\n    [\"de\",      /^de([_-]|$)/i,      () => msg(\"German\"),                async () => await import(\"@goauthentik/locales/de\")],\n    [\"en\",      /^en([_-]|$)/i,      () => msg(\"English\"),               async () => await import(\"@goauthentik/locales/en\")],\n    [\"es\",      /^es([_-]|$)/i,      () => msg(\"Spanish\"),               async () => await import(\"@goauthentik/locales/es\")],\n    [\"fr\",      /^fr([_-]|$)/i,      () => msg(\"French\"),                async () => await import(\"@goauthentik/locales/fr\")],\n    [\"it\",      /^it([_-]|$)/i,      () => msg(\"Italian\"),               async () => await import(\"@goauthentik/locales/it\")],\n    [\"ko\",      /^ko([_-]|$)/i,      () => msg(\"Korean\"),                async () => await import(\"@goauthentik/locales/ko\")],\n    [\"nl\",      /^nl([_-]|$)/i,      () => msg(\"Dutch\"),                 async () => await import(\"@goauthentik/locales/nl\")],\n    [\"pl\",      /^pl([_-]|$)/i,      () => msg(\"Polish\"),                async () => await import(\"@goauthentik/locales/pl\")],\n    [\"ru\",      /^ru([_-]|$)/i,      () => msg(\"Russian\"),               async () => await import(\"@goauthentik/locales/ru\")],\n    [\"tr\",      /^tr([_-]|$)/i,      () => msg(\"Turkish\"),               async () => await import(\"@goauthentik/locales/tr\")],\n    [\"zh_TW\",   /^zh[_-]TW$/i,       () => msg(\"Taiwanese Mandarin\"),    async () => await import(\"@goauthentik/locales/zh_TW\")],\n    [\"zh-Hans\", /^zh(\\b|_)/i,        () => msg(\"Chinese (simplified)\"),  async () => await import(\"@goauthentik/locales/zh-Hans\")],\n    [\"zh-Hant\", /^zh[_-](HK|Hant)/i, () => msg(\"Chinese (traditional)\"), async () => await import(\"@goauthentik/locales/zh-Hant\")],\n    debug\n];\n\nexport const LOCALES: AkLocale[] = LOCALE_TABLE.map(([code, match, label, locale]) => ({\n    code,\n    match,\n    label,\n    locale,\n}));\n\nexport default LOCALES;\n", "/**\n * @license\n * Copyright 2021 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {ContextType, Context} from './create-context.js';\n\ndeclare global {\n  interface HTMLElementEventMap {\n    /**\n     * A 'context-request' event can be emitted by any element which desires\n     * a context value to be injected by an external provider.\n     */\n    'context-request': ContextRequestEvent<Context<unknown, unknown>>;\n  }\n}\n\n/**\n * A callback which is provided by a context requester and is called with the value satisfying the request.\n * This callback can be called multiple times by context providers as the requested value is changed.\n */\nexport type ContextCallback<ValueType> = (\n  value: ValueType,\n  unsubscribe?: () => void\n) => void;\n\n/**\n * Interface definition for a ContextRequest\n */\nexport interface ContextRequest<C extends Context<unknown, unknown>> {\n  readonly context: C;\n  readonly callback: ContextCallback<ContextType<C>>;\n  readonly subscribe?: boolean;\n}\n\n/**\n * An event fired by a context requester to signal it desires a specified context with the given key.\n *\n * A provider should inspect the `context` property of the event to determine if it has a value that can\n * satisfy the request, calling the `callback` with the requested value if so.\n *\n * If the requested context event contains a truthy `subscribe` value, then a provider can call the callback\n * multiple times if the value is changed, if this is the case the provider should pass an `unsubscribe`\n * method to the callback which consumers can invoke to indicate they no longer wish to receive these updates.\n *\n * If no `subscribe` value is present in the event, then the provider can assume that this is a 'one time'\n * request for the context and can therefore not track the consumer.\n */\nexport class ContextRequestEvent<C extends Context<unknown, unknown>>\n  extends Event\n  implements ContextRequest<C>\n{\n  readonly context: C;\n  readonly callback: ContextCallback<ContextType<C>>;\n  readonly subscribe?: boolean;\n\n  /**\n   *\n   * @param context the context key to request\n   * @param callback the callback that should be invoked when the context with the specified key is available\n   * @param subscribe when, true indicates we want to subscribe to future updates\n   */\n  constructor(\n    context: C,\n    callback: ContextCallback<ContextType<C>>,\n    subscribe?: boolean\n  ) {\n    super('context-request', {bubbles: true, composed: true});\n    this.context = context;\n    this.callback = callback;\n    this.subscribe = subscribe ?? false;\n  }\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {\n  ContextCallback,\n  ContextRequestEvent,\n} from '../context-request-event.js';\nimport type {Context, ContextType} from '../create-context.js';\nimport type {\n  ReactiveController,\n  ReactiveControllerHost,\n} from '@lit/reactive-element';\n\nexport interface Options<C extends Context<unknown, unknown>> {\n  context: C;\n  callback?: (value: ContextType<C>, dispose?: () => void) => void;\n  subscribe?: boolean;\n}\n\n/**\n * A ReactiveController which adds context consuming behavior to a custom\n * element by dispatching `context-request` events.\n *\n * When the host element is connected to the document it will emit a\n * `context-request` event with its context key. When the context request\n * is satisfied the controller will invoke the callback, if present, and\n * trigger a host update so it can respond to the new value.\n *\n * It will also call the dispose method given by the provider when the\n * host element is disconnected.\n */\nexport class ContextConsumer<\n  C extends Context<unknown, unknown>,\n  HostElement extends ReactiveControllerHost & HTMLElement,\n> implements ReactiveController\n{\n  protected host: HostElement;\n  private context: C;\n  private callback?: (value: ContextType<C>, dispose?: () => void) => void;\n  private subscribe = false;\n\n  private provided = false;\n\n  value?: ContextType<C> = undefined;\n\n  constructor(host: HostElement, options: Options<C>);\n  /** @deprecated Use new ContextConsumer(host, options) */\n  constructor(\n    host: HostElement,\n    context: C,\n    callback?: (value: ContextType<C>, dispose?: () => void) => void,\n    subscribe?: boolean\n  );\n  constructor(\n    host: HostElement,\n    contextOrOptions: C | Options<C>,\n    callback?: (value: ContextType<C>, dispose?: () => void) => void,\n    subscribe?: boolean\n  ) {\n    this.host = host;\n    // This is a potentially fragile duck-type. It means a context object can't\n    // have a property name context and be used in positional argument form.\n    if ((contextOrOptions as Options<C>).context !== undefined) {\n      const options = contextOrOptions as Options<C>;\n      this.context = options.context;\n      this.callback = options.callback;\n      this.subscribe = options.subscribe ?? false;\n    } else {\n      this.context = contextOrOptions as C;\n      this.callback = callback;\n      this.subscribe = subscribe ?? false;\n    }\n    this.host.addController(this);\n  }\n\n  private unsubscribe?: () => void;\n\n  hostConnected(): void {\n    this.dispatchRequest();\n  }\n\n  hostDisconnected(): void {\n    if (this.unsubscribe) {\n      this.unsubscribe();\n      this.unsubscribe = undefined;\n    }\n  }\n\n  private dispatchRequest() {\n    this.host.dispatchEvent(\n      new ContextRequestEvent(this.context, this._callback, this.subscribe)\n    );\n  }\n\n  // This function must have stable identity to properly dedupe in ContextRoot\n  // if this element connects multiple times.\n  private _callback: ContextCallback<ContextType<C>> = (value, unsubscribe) => {\n    // some providers will pass an unsubscribe function indicating they may provide future values\n    if (this.unsubscribe) {\n      // if the unsubscribe function changes this implies we have changed provider\n      if (this.unsubscribe !== unsubscribe) {\n        // cleanup the old provider\n        this.provided = false;\n        this.unsubscribe();\n      }\n      // if we don't support subscription, immediately unsubscribe\n      if (!this.subscribe) {\n        this.unsubscribe();\n      }\n    }\n\n    // store the value so that it can be retrieved from the controller\n    this.value = value;\n    // schedule an update in case this value is used in a template\n    this.host.requestUpdate();\n\n    // only invoke callback if we are either expecting updates or have not yet\n    // been provided a value\n    if (!this.provided || this.subscribe) {\n      this.provided = true;\n      if (this.callback) {\n        this.callback(value, unsubscribe);\n      }\n    }\n\n    this.unsubscribe = unsubscribe;\n  };\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {ReactiveElement} from '@lit/reactive-element';\nimport {ContextConsumer} from '../controllers/context-consumer.js';\nimport {Context} from '../create-context.js';\n\n/*\n * IMPORTANT: For compatibility with tsickle and the Closure JS compiler, all\n * property decorators (but not class decorators) in this file that have\n * an @ExportDecoratedItems annotation must be defined as a regular function,\n * not an arrow function.\n */\n\n/**\n * A property decorator that adds a ContextConsumer controller to the component\n * which will try and retrieve a value for the property via the Context API.\n *\n * @param context A Context identifier value created via `createContext`\n * @param subscribe An optional boolean which when true allows the value to be updated\n *   multiple times.\n *\n * @example\n *\n * ```ts\n * import {consume} from '@lit/context';\n * import {loggerContext, Logger} from 'community-protocols/logger';\n *\n * class MyElement {\n *   @consume({context: loggerContext})\n *   logger?: Logger;\n *\n *   doThing() {\n *     this.logger!.log('thing was done');\n *   }\n * }\n * ```\n * @category Decorator\n */\nexport function consume<ValueType>({\n  context,\n  subscribe,\n}: {\n  context: Context<unknown, ValueType>;\n  subscribe?: boolean;\n}): ConsumeDecorator<ValueType> {\n  return ((\n    protoOrTarget: ClassAccessorDecoratorTarget<ReactiveElement, ValueType>,\n    nameOrContext:\n      | PropertyKey\n      | ClassAccessorDecoratorContext<ReactiveElement, ValueType>\n  ) => {\n    if (typeof nameOrContext === 'object') {\n      // Standard decorators branch\n      nameOrContext.addInitializer(function () {\n        new ContextConsumer(this, {\n          context,\n          callback: (value) => {\n            protoOrTarget.set.call(this, value);\n          },\n          subscribe,\n        });\n      });\n    } else {\n      // Experimental decorators branch\n      (protoOrTarget.constructor as typeof ReactiveElement).addInitializer(\n        (element: ReactiveElement): void => {\n          new ContextConsumer(element, {\n            context,\n            callback: (value) => {\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              (element as any)[nameOrContext] = value;\n            },\n            subscribe,\n          });\n        }\n      );\n    }\n  }) as ConsumeDecorator<ValueType>;\n}\n\n/**\n * Generates a public interface type that removes private and protected fields.\n * This allows accepting otherwise incompatible versions of the type (e.g. from\n * multiple copies of the same package in `node_modules`).\n */\ntype Interface<T> = {\n  [K in keyof T]: T[K];\n};\n\ntype ConsumeDecorator<ValueType> = {\n  // legacy\n  <\n    K extends PropertyKey,\n    Proto extends Interface<Omit<ReactiveElement, 'renderRoot'>>,\n  >(\n    protoOrDescriptor: Proto,\n    name?: K\n  ): FieldMustMatchProvidedType<Proto, K, ValueType>;\n\n  // standard\n  <\n    C extends Interface<Omit<ReactiveElement, 'renderRoot'>>,\n    V extends ValueType,\n  >(\n    value: ClassAccessorDecoratorTarget<C, V>,\n    context: ClassAccessorDecoratorContext<C, V>\n  ): void;\n};\n\n// Note TypeScript requires the return type of a decorator to be `void | any`\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype DecoratorReturn = void | any;\n\ntype FieldMustMatchProvidedType<Obj, Key extends PropertyKey, ProvidedType> =\n  // First we check whether the object has the property as a required field\n  Obj extends Record<Key, infer ConsumingType>\n    ? // Ok, it does, just check whether it's ok to assign the\n      // provided type to the consuming field\n      [ProvidedType] extends [ConsumingType]\n      ? DecoratorReturn\n      : {\n          message: 'provided type not assignable to consuming field';\n          provided: ProvidedType;\n          consuming: ConsumingType;\n        }\n    : // Next we check whether the object has the property as an optional field\n      Obj extends Partial<Record<Key, infer ConsumingType>>\n      ? // Check assignability again. Note that we have to include undefined\n        // here on the consuming type because it's optional.\n        [ProvidedType] extends [ConsumingType | undefined]\n        ? DecoratorReturn\n        : {\n            message: 'provided type not assignable to consuming field';\n            provided: ProvidedType;\n            consuming: ConsumingType | undefined;\n          }\n      : // Ok, the field isn't present, so either someone's using consume\n        // manually, i.e. not as a decorator (maybe don't do that! but if you do,\n        // you're on your own for your type checking, sorry), or the field is\n        // private, in which case we can't check it.\n        DecoratorReturn;\n", "/**\n * @license\n * Copyright 2021 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {ContextCallback} from './context-request-event.js';\n\n/**\n * A disposer function\n */\ntype Disposer = () => void;\n\ninterface CallbackInfo {\n  disposer: Disposer;\n  consumerHost: Element;\n}\n\n/**\n * A simple class which stores a value, and triggers registered callbacks when\n * the value is changed via its setter.\n *\n * An implementor might use other observable patterns such as MobX or Redux to\n * get behavior like this. But this is a pretty minimal approach that will\n * likely work for a number of use cases.\n */\nexport class ValueNotifier<T> {\n  protected readonly subscriptions = new Map<\n    ContextCallback<T>,\n    CallbackInfo\n  >();\n  private _value!: T;\n  get value(): T {\n    return this._value;\n  }\n  set value(v: T) {\n    this.setValue(v);\n  }\n\n  setValue(v: T, force = false) {\n    const update = force || !Object.is(v, this._value);\n    this._value = v;\n    if (update) {\n      this.updateObservers();\n    }\n  }\n\n  constructor(defaultValue?: T) {\n    if (defaultValue !== undefined) {\n      this.value = defaultValue;\n    }\n  }\n\n  updateObservers = (): void => {\n    for (const [callback, {disposer}] of this.subscriptions) {\n      callback(this._value, disposer);\n    }\n  };\n\n  addCallback(\n    callback: ContextCallback<T>,\n    consumerHost: Element,\n    subscribe?: boolean\n  ): void {\n    if (!subscribe) {\n      // just call the callback once and we're done\n      callback(this.value);\n      return;\n    }\n    if (!this.subscriptions.has(callback)) {\n      this.subscriptions.set(callback, {\n        disposer: () => {\n          this.subscriptions.delete(callback);\n        },\n        consumerHost,\n      });\n    }\n    const {disposer} = this.subscriptions.get(callback)!;\n    callback(this.value, disposer);\n  }\n\n  clearCallbacks(): void {\n    this.subscriptions.clear();\n  }\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\nimport {ContextRequestEvent} from '../context-request-event.js';\nimport {ValueNotifier} from '../value-notifier.js';\nimport type {Context, ContextType} from '../create-context.js';\nimport type {\n  ReactiveController,\n  ReactiveControllerHost,\n} from '@lit/reactive-element';\n\ndeclare global {\n  interface HTMLElementEventMap {\n    /**\n     * A 'context-provider' event can be emitted by any element which hosts\n     * a context provider to indicate it is available for use.\n     */\n    'context-provider': ContextProviderEvent<Context<unknown, unknown>>;\n  }\n}\n\nexport class ContextProviderEvent<\n  C extends Context<unknown, unknown>,\n> extends Event {\n  readonly context: C;\n\n  /**\n   *\n   * @param context the context which this provider can provide\n   */\n  constructor(context: C) {\n    super('context-provider', {bubbles: true, composed: true});\n    this.context = context;\n  }\n}\n\nexport interface Options<C extends Context<unknown, unknown>> {\n  context: C;\n  initialValue?: ContextType<C>;\n}\n\ntype ReactiveElementHost = Partial<ReactiveControllerHost> & HTMLElement;\n\n/**\n * A ReactiveController which adds context provider behavior to a\n * custom element.\n *\n * This controller simply listens to the `context-request` event when\n * the host is connected to the DOM and registers the received callbacks\n * against its observable Context implementation.\n *\n * The controller may also be attached to any HTML element in which case it's\n * up to the user to call hostConnected() when attached to the DOM. This is\n * done automatically for any custom elements implementing\n * ReactiveControllerHost.\n */\nexport class ContextProvider<\n    T extends Context<unknown, unknown>,\n    HostElement extends ReactiveElementHost = ReactiveElementHost,\n  >\n  extends ValueNotifier<ContextType<T>>\n  implements ReactiveController\n{\n  protected readonly host: HostElement;\n  private readonly context: T;\n\n  constructor(host: HostElement, options: Options<T>);\n  /** @deprecated Use new ContextProvider(host, options) */\n  constructor(host: HostElement, context: T, initialValue?: ContextType<T>);\n  constructor(\n    host: HostElement,\n    contextOrOptions: T | Options<T>,\n    initialValue?: ContextType<T>\n  ) {\n    super(\n      (contextOrOptions as Options<T>).context !== undefined\n        ? (contextOrOptions as Options<T>).initialValue\n        : initialValue\n    );\n    this.host = host;\n    if ((contextOrOptions as Options<T>).context !== undefined) {\n      this.context = (contextOrOptions as Options<T>).context;\n    } else {\n      this.context = contextOrOptions as T;\n    }\n    this.attachListeners();\n    this.host.addController?.(this);\n  }\n\n  onContextRequest = (\n    ev: ContextRequestEvent<Context<unknown, unknown>>\n  ): void => {\n    // Only call the callback if the context matches.\n    // Also, in case an element is a consumer AND a provider\n    // of the same context, we want to avoid the element to self-register.\n    // The check on composedPath (as opposed to ev.target) is to cover cases\n    // where the consumer is in the shadowDom of the provider (in which case,\n    // event.target === this.host because of event retargeting).\n    const consumerHost = ev.composedPath()[0] as Element;\n    if (ev.context !== this.context || consumerHost === this.host) {\n      return;\n    }\n    ev.stopPropagation();\n    this.addCallback(ev.callback, consumerHost, ev.subscribe);\n  };\n\n  /**\n   * When we get a provider request event, that means a child of this element\n   * has just woken up. If it's a provider of our context, then we may need to\n   * re-parent our subscriptions, because is a more specific provider than us\n   * for its subtree.\n   */\n  onProviderRequest = (\n    ev: ContextProviderEvent<Context<unknown, unknown>>\n  ): void => {\n    // Ignore events when the context doesn't match.\n    // Also, in case an element is a consumer AND a provider\n    // of the same context it shouldn't provide to itself.\n    // We use composedPath (as opposed to ev.target) to cover cases\n    // where the consumer is in the shadowDom of the provider (in which case,\n    // event.target === this.host because of event retargeting).\n    const childProviderHost = ev.composedPath()[0] as Element;\n    if (ev.context !== this.context || childProviderHost === this.host) {\n      return;\n    }\n    // Re-parent all of our subscriptions in case this new child provider\n    // should take them over.\n    const seen = new Set<unknown>();\n    for (const [callback, {consumerHost}] of this.subscriptions) {\n      // Prevent infinite loops in the case where a one host element\n      // is providing the same context multiple times.\n      //\n      // While normally it's a no-op to attempt to re-parent a subscription\n      // that already has its proper parent, in the case where there's more\n      // than one ValueProvider for the same context on the same hostElement,\n      // they will each call the consumer, and since they will each have their\n      // own dispose function, a well behaved consumer will notice the change\n      // in dispose function and call their old one.\n      //\n      // This will cause the subscriptions to thrash, but worse, without this\n      // set check here, we can end up in an infinite loop, as we add and remove\n      // the same subscriptions onto the end of the map over and over.\n      if (seen.has(callback)) {\n        continue;\n      }\n      seen.add(callback);\n      consumerHost.dispatchEvent(\n        new ContextRequestEvent(this.context, callback, true)\n      );\n    }\n    ev.stopPropagation();\n  };\n\n  private attachListeners() {\n    this.host.addEventListener('context-request', this.onContextRequest);\n    this.host.addEventListener('context-provider', this.onProviderRequest);\n  }\n\n  hostConnected(): void {\n    // emit an event to signal a provider is available for this context\n    this.host.dispatchEvent(new ContextProviderEvent(this.context));\n  }\n}\n", "import { createContext } from \"@lit/context\";\n\nimport type { Config, CurrentBrand, LicenseSummary, SessionUser, Version } from \"@goauthentik/api\";\n\nexport const authentikConfigContext = createContext<Config>(Symbol(\"authentik-config-context\"));\n\nexport const authentikUserContext = createContext<SessionUser>(Symbol(\"authentik-user-context\"));\n\nexport const authentikEnterpriseContext = createContext<LicenseSummary>(\n    Symbol(\"authentik-enterprise-context\"),\n);\n\nexport const authentikBrandContext = createContext<CurrentBrand>(Symbol(\"authentik-brand-context\"));\n\nexport const authentikVersionContext = createContext<Version>(Symbol(\"authentik-version-context\"));\n\nexport default authentikConfigContext;\n"],
  "mappings": "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",
  "names": ["enLocale", "en_exports", "debug", "msg", "LOCALE_TABLE", "LOCALES", "code", "match", "label", "locale", "ContextRequestEvent", "Event", "context", "callback", "subscribe", "super", "bubbles", "composed", "this", "ContextConsumer", "host", "contextOrOptions", "callback", "subscribe", "this", "provided", "value", "_callback", "unsubscribe", "requestUpdate", "context", "options", "addController", "hostConnected", "dispatchRequest", "hostDisconnected", "dispatchEvent", "ContextRequestEvent", "consume", "context", "subscribe", "protoOrTarget", "nameOrContext", "addInitializer", "ContextConsumer", "this", "callback", "value", "set", "call", "constructor", "element", "ValueNotifier", "value", "this", "_value", "v", "setValue", "force", "update", "Object", "is", "updateObservers", "defaultValue", "subscriptions", "Map", "callback", "disposer", "consumerHost", "subscribe", "has", "set", "delete", "get", "clearCallbacks", "clear", "ContextProviderEvent", "Event", "context", "super", "bubbles", "composed", "this", "ContextProvider", "ValueNotifier", "host", "contextOrOptions", "initialValue", "onContextRequest", "ev", "consumerHost", "composedPath", "stopPropagation", "addCallback", "callback", "subscribe", "onProviderRequest", "childProviderHost", "seen", "Set", "subscriptions", "has", "add", "dispatchEvent", "ContextRequestEvent", "attachListeners", "addController", "addEventListener", "hostConnected", "authentikConfigContext", "authentikUserContext", "authentikEnterpriseContext", "authentikBrandContext", "authentikVersionContext"]
}