@snap/camera-kit 1.10.0 → 1.12.0

package/README.md

@@ -4,26 +4,28 @@ The Camera Kit Web SDK allows web developers to build Snap's core AR Lens techno
 
 ## Minimum browser requirements
 
-- **Chrome 73+**
-- **Safari 15+**
-  - MacOS 12+, iOS 15+, iPadOS 15+
-  - SIMD: Unsupported
-  - Web Worker Mode\*: Unsupported
-- **Edge 79+**
-  - Edge is still currently under evaluation. However, since New Edge is Chromium based, the expectations are similar to that of Chrome.
-- **Firefox** - Under Evaluation
-  - Web Worker Mode\*: Firefox 105+
+-   **Chrome 95+**
+-   **Safari 16+**
+    -   MacOS 12+, iOS 15+, iPadOS 15+
+    -   SIMD: Unsupported
+    -   Web Worker Mode\*: Unsupported
+-   **Edge 79+**
+    -   Edge is still currently under evaluation. However, since New Edge is Chromium based, the expectations are similar to that of Chrome.
+-   **Firefox** — Under Evaluation
+    -   Web Worker Mode\*: Firefox 105+
 
 \*Web Worker Mode requires `OffscreenCanvas` support.
 
 ## Prerequisites
 
 ### Snap Developer set up
+
 You'll need a Snap Developer account, and you'll need to apply for access to Camera Kit Web SDK. You can find more info on that [here](https://docs.snap.com/camera-kit/getting-started/setting-up-accounts).
 
 You may also want to familiarize yourself with how to access and manage AR content (i.e. Lenses). You read about that [here](https://docs.snap.com/camera-kit/ar-content/camera-kit-portal).
 
 ### Development environment
+
 This guide assumes you've already set up an [NPM](https://www.npmjs.com/) package, you're using [TypeScript](https://www.typescriptlang.org/), and have some way to build and host your project during development (e.g. using [Webpack](https://webpack.js.org/)).
 
 #### Using the SDK in a JavaScript project
@@ -36,8 +38,8 @@ If your project already has a [Content Security Policy](https://developer.mozill
 
 When it bootstraps, Camera Kit Web SDK downloads an executable WebAssembly file containing the Lens rendering engine. This file is served from an optimized CDN managed by Snap. You'll need to make sure your Content Security Policy allows this file to be executed.
 
-- `connect-src` must include `https://*.snapar.com`, otherwise Camera Kit Web will fail to initialize.
-- `script-src` must include `https://cf-st.sc-cdn.net/ blob: 'wasm-unsafe-eval'`.
+-   `connect-src` must include `https://*.snapar.com`, otherwise Camera Kit Web will fail to initialize.
+-   `script-src` must include `https://cf-st.sc-cdn.net/ blob: 'wasm-unsafe-eval'`.
 
 _Note: Some older browser versions may not support the `'wasm-unsafe-eval'` source value, and it may be necessary to use `'unsafe-eval'` to allow Camera Kit's downloaded WebAssembly to run._
 
@@ -87,8 +89,8 @@ canvasContainer.appendChild(session.output.live);
 
 There are actually two different output canvases:
 
-- `live`: This canvas renders content intended for the Lens user. Depending on the Lens being used, this canvas may include UI elements, prompts, or other content that is only meant to be seen by the user of the Lens.
-- `capture`: This canvas renders content intended for presenting to other users.
+-   `live`: This canvas renders content intended for the Lens user. Depending on the Lens being used, this canvas may include UI elements, prompts, or other content that is only meant to be seen by the user of the Lens.
+-   `capture`: This canvas renders content intended for presenting to other users.
 
 These two output canvases correspond to the two different [RenderTargets](https://docs.snap.com/lens-studio/references/guides/lens-features/scene-set-up/camera#render-target) a Lens may use to render its content. Not all Lenses will render different content to `live` vs. `capture`, so it's important to understand how the Lenses you'll be using use these two different outputs.
 
@@ -105,10 +107,10 @@ The most common source of input media is the user's webcam. Camera Kit Web SDK p
 Once we have a `CameraKitSource`, we can tell the `CameraKitSession` to use this source for rendering.
 
 ```ts
-import { createMediaStreamSource, Transform2D } from "@snap/camera-kit"
+import { createMediaStreamSource, Transform2D } from "@snap/camera-kit";
 
 const stream = await navigator.mediaDevices.getUserMedia({ video: true });
-const source = createMediaStreamSource(stream, { transform: Transform2D.MirrorX, cameraType: 'user' });
+const source = createMediaStreamSource(stream, { transform: Transform2D.MirrorX, cameraType: "user" });
 await session.setSource(source);
 ```
 
@@ -116,9 +118,9 @@ In this example, we also mirror the source stream (which feels more natural in m
 
 Camera Kit Web SDK has helper methods to create a `CameraKitSource` from:
 
-- A `MediaStream` object, which could come from the user's camera, a WebRTC connection, a `<canvas>` via the [`captureStream()` method](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/captureStream), or elsewhere.
-- A `<video>` element (i.e. `HTMLVideoElement`)
-- An `<img>`element (i.e. `HTMLImageElement`)
+-   A `MediaStream` object, which could come from the user's camera, a WebRTC connection, a `<canvas>` via the [`captureStream()` method](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/captureStream), or elsewhere.
+-   A `<video>` element (i.e. `HTMLVideoElement`)
+-   An `<img>`element (i.e. `HTMLImageElement`)
 
 ## Loading, applying, and removing Lenses
 
@@ -134,19 +136,18 @@ const lens = await cameraKit.lensRepository.loadLens("<Lens ID>", "<Lens Group I
 await session.applyLens(lens);
 
 // Loading one or more Lens Groups – Lenses from all groups are returned as a single array of lenses.
-const { lenses } = await cameraKit.lensRepository.loadLensGroups([
-    "<Lens Group ID 1>",
-    "<Lens Group ID 2>",
-]);
+const { lenses } = await cameraKit.lensRepository.loadLensGroups(["<Lens Group ID 1>", "<Lens Group ID 2>"]);
 await session.applyLens(lenses[0]);
 ```
 
 ### Removing the Lens
 
 You can also remove the currently-applied Lens:
+
 ```ts
 await session.removeLens();
 ```
+
 After removing the Lens, when the session renders it will simply render the input media directly to the output canvas.
 
 ## Playback
@@ -165,36 +166,36 @@ session.pause();
 By default, `play()` will only begin rendering the `live` output canvas. You can specify which canvas to render by passing an argument:
 
 ```ts
-session.play('live');
-session.play('capture');
+session.play("live");
+session.play("capture");
 ```
 
 Calling `pause()` with no arguments will pause both outputs. But just like with `play()`, you can pass an argument to select which canvas to pause.
 
 ```ts
-session.pause('live');
-session.pause('capture');
+session.pause("live");
+session.pause("capture");
 ```
 
-> - _`live`: This canvas renders content intended for the Lens user. Depending on the Lens being used, this canvas may include UI elements, prompts, or other content that is only meant to be seen by the user of the Lens._
-> - _`capture`: This canvas renders content intended for presenting to other users._
+> -   _`live`: This canvas renders content intended for the Lens user. Depending on the Lens being used, this canvas may include UI elements, prompts, or other content that is only meant to be seen by the user of the Lens._
+> -   _`capture`: This canvas renders content intended for presenting to other users._
 
 ## Error Handling
 
-Camera Kit Web SDK methods may throw errors, or return rejected Promises -- these are documented in the [API docs](https://kit.snapchat.com/reference/CameraKit/web/1.10.0/index.html). It is good practice to handle such cases, to provide a good experience to your users.
+Camera Kit Web SDK methods may throw errors, or return rejected Promises -- these are documented in the [API docs](https://kit.snapchat.com/reference/CameraKit/web/1.12.0/index.html). It is good practice to handle such cases, to provide a good experience to your users.
 
 Errors may also occur during Lens rendering. For example, Lenses contain their own scripting, which could throw an error. A rendering error could also occur if a Lens attempts to use a feature that is not supported by Camera Kit Web SDK.
 
 When a `LensExecutionError` such as these occurs, the Lens is **automatically removed** from the `CameraKitSession`. An error event is emitted so that your application can respond appropriately. You can listen to these error events like so:
 
 ```ts
-session.events.addEventListener('error', (event) => {
-  console.error(event.detail.error);
+session.events.addEventListener("error", (event) => {
+    console.error(event.detail.error);
 
-  if (event.detail.error.name === 'LensExecutionError') {
-    // The currently-applied Lens encountered a problem that is most likely unrecoverable and the Lens has been removed.
-    // Your application may want to prevent this Lens from being applied again.
-  }
+    if (event.detail.error.name === "LensExecutionError") {
+        // The currently-applied Lens encountered a problem that is most likely unrecoverable and the Lens has been removed.
+        // Your application may want to prevent this Lens from being applied again.
+    }
 });
 ```
 
@@ -211,14 +212,14 @@ import { boostrapCameraKit, createMediaStreamSource } from "@snap/camera-kit";
 
     const canvas = document.getElementById("my-canvas");
     const session = await cameraKit.createSession({ liveRenderTarget: canvas });
-    session.events.addEventListener('error', (event) => {
-      if (event.detail.error.name === 'LensExecutionError') {
-        console.log('The current Lens encountered an error and was removed.', event.detail.error);
-      }
+    session.events.addEventListener("error", (event) => {
+        if (event.detail.error.name === "LensExecutionError") {
+            console.log("The current Lens encountered an error and was removed.", event.detail.error);
+        }
     });
 
     const stream = await navigator.mediaDevices.getUserMedia({ video: true });
-    const source = createMediaStreamSource(stream, { transform: Transform2D.MirrorX, cameraType: 'user' });
+    const source = createMediaStreamSource(stream, { transform: Transform2D.MirrorX, cameraType: "user" });
     await session.setSource(source);
 
     const lens = await cameraKit.lensRepository.loadLens("<Lens ID>", "<Lens Group ID>");
@@ -239,8 +240,8 @@ By default, Camera Kit Web SDK does very minimal logging. Specifying `'console'`
 
 ```ts
 const cameraKit = await bootstrapCameraKit({
-  apiToken: '<apiToken>',
-  logger: 'console',
+    apiToken: "<apiToken>",
+    logger: "console",
 });
 ```
 
@@ -249,7 +250,7 @@ const cameraKit = await bootstrapCameraKit({
 Some Lenses allow for keyboard input. The SDK provides a `<textarea>` (`HTMLTextAreaElement`) element that can be added to your page, and will send its text to the active Lens whenever the user presses the `Enter` key.
 
 ```ts
-const textAreaContainer = document.getElementById('text-area-container');
+const textAreaContainer = document.getElementById("text-area-container");
 const textArea = session.keyboard.getElement();
 textAreaContainer.appendChild(textArea);
 ```
@@ -257,14 +258,14 @@ textAreaContainer.appendChild(textArea);
 Alternatively, an event is emitted when a Lens is expecting text input. You can then implement your own UI and logic for obtaining text input from your users, and then send it back to the Lens. For example, something like:
 
 ```ts
-const input = document.getElementById('my-text-area');
-session.keyboard.addEventListener('active', () => {
-  input.classList.remove('hidden');
+const input = document.getElementById("my-text-area");
+session.keyboard.addEventListener("active", () => {
+    input.classList.remove("hidden");
 });
 
-input.addEventListener('keyup', () => {
-  session.keyboard.sendInputToLens(input.value);
-})
+input.addEventListener("keyup", () => {
+    session.keyboard.sendInputToLens(input.value);
+});
 ```
 
 See an example of this [here](https://camera-kit.snapchat.com/websdk/sample/keyboard).
@@ -280,7 +281,7 @@ Keep in mind that this controls Camera Kit's render resolution, and not (necessa
 Most of the time you'll not need to set the render size – but it could be useful if your video source is, say, very high resolution. In that case, you may observe better performance by telling Camera Kit to render at a lower resolution.
 
 ```ts
-await session.setSource(source)
+await session.setSource(source);
 // This must be done *after* calling `setSource()`
 await source.setRenderSize(width, height);
 ```
@@ -293,7 +294,7 @@ When setting up a `CameraKitSource`, you can specify whether or not it is a fron
 
 ```ts
 const stream = await navigator.mediaDevices.getUserMedia(constraints);
-const source = createMediaStreamSource(stream, { cameraType: 'environment' });
+const source = createMediaStreamSource(stream, { cameraType: "environment" });
 await session.setSource(source);
 ```
 
@@ -323,7 +324,7 @@ Any `CameraKitSource` can be transformed using a matrix, to rotate, scale, or mi
 ```ts
 import { Transform2D } from "@snap/camera-kit";
 
-await session.setSource(source)
+await session.setSource(source);
 // This must be done *after* calling `setSource()`
 source.setTransform(Transform2D.MirrorX);
 ```
@@ -337,8 +338,9 @@ Camera Kit Web SDK reports certain important events which may be of interest to
 Currently, the only event that may be of interest is the `lensView` event. It is emitted whenever a lens is _removed_ from the `CameraKitSession`, indicating a complete lens view. It contains information about the lens' performance (e.g. fps, frame processing times, etc.) and how long the lens was applied.
 
 You may listen to these events like so:
+
 ```ts
-cameraKit.metrics.addEventListener('lensView', (event) => {
-  console.debug(event.detail);
+cameraKit.metrics.addEventListener("lensView", (event) => {
+    console.debug(event.detail);
 });
 ```

package/dist/CameraKit.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="trusted-types" />
 import type { Container } from "@snap/ts-inject";
 import type { LensRepository } from "./lens/LensRepository";
 import type { LensCoreError } from "./lens-core-module/lensCoreError";
@@ -207,6 +208,7 @@ export declare const cameraKitFactory: {
         setClientInterfaceRequestHandler: (callback: import("./lens-core-module/generated-types").ClientInterfaceRequestHandler) => void;
         setPreloadedConfiguration: (config: import("./lens-core-module/generated-types").SetPreloadedConfigurationInput) => void;
         setAllSoundsMuted: (config: import("./lens-core-module/generated-types").SetAllSoundsMutedInput) => void;
+        setSystemFontFamilies: (config: import("./lens-core-module/generated-types").SetSystemFontFamiliesInput) => void;
         setSystemFonts: (config: import("./lens-core-module/generated-types").SetSystemFontsInput) => void;
         registerBeginWebXrHandler: (handler: ((config: import("./lens-core-module/generated-types").BeginWebXrInput) => void) | null) => void;
         registerEndWebXrHandler: (handler: (() => void) | null) => void;
@@ -243,6 +245,11 @@ export declare const cameraKitFactory: {
             onFrameProcessed?: ((arg: import("./lens-core-module/generated-types").OnFrameProcessedParam) => void) | undefined;
             xrCapabilities?: import("./lens-core-module/generated-types").XrCapabilities | undefined;
             exceptionHandler?: ((err: LensCoreError) => void) | undefined;
+            trustedTypes?: {
+                policyName: string;
+                getTrustedUrls: () => string[];
+                trustUrl: (url: string) => string | TrustedScriptURL;
+            } | undefined;
         }): Promise<void>;
         provideRemoteAssetsResponse(input: {
             assetId: string;

package/dist/CameraKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CameraKit.d.ts","sourceRoot":"","sources":["../src/CameraKit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAKnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAUvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAG9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAYtF;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GACvB,gBAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,GAC5C,gBAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC;AAEnD;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;IAErC;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,SAAS;IAad;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,cAAc;IAEvC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY;IApBjC,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,cAAc,CAAA;KAAE,CAAC;IAEhD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,CAA0B;IAE/E,OAAO,CAAC,QAAQ,CAA0B;IAE1C,gBAAgB;;IAEZ;;OAEG;IACM,cAAc,EAAE,cAAc,EAEtB,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,cAAc,EAC9B,SAAS,EAAE,SAAS,CAAC,YAAY,CAAC,EAClC,YAAY,EAAE,mBAAmB,EAClD,UAAU,EAAE,kBAAkB;IAUlC;;;;;;;;;;;;;;;;OAgBG;IAEG,aAAa,CAAC,EAChB,gBAAgB,EAChB,oBAAoB,GACvB,GAAE,oBAAyB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAoGxD;;OAEG;IAEG,OAAO;CAMhB;AAED,gBAAgB;AAChB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkB5B,CAAC"}
+{"version":3,"file":"CameraKit.d.ts","sourceRoot":"","sources":["../src/CameraKit.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAKnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAUvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAG9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAatF;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GACvB,gBAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,GAC5C,gBAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC;AAEnD;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;IAErC;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,SAAS;IAad;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,cAAc;IAEvC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY;IApBjC,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,cAAc,CAAA;KAAE,CAAC;IAEhD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,CAA0B;IAE/E,OAAO,CAAC,QAAQ,CAA0B;IAE1C,gBAAgB;;IAEZ;;OAEG;IACM,cAAc,EAAE,cAAc,EAEtB,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,cAAc,EAC9B,SAAS,EAAE,SAAS,CAAC,YAAY,CAAC,EAClC,YAAY,EAAE,mBAAmB,EAClD,UAAU,EAAE,kBAAkB;IAUlC;;;;;;;;;;;;;;;;OAgBG;IAEG,aAAa,CAAC,EAChB,gBAAgB,EAChB,oBAAoB,GACvB,GAAE,oBAAyB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA0GxD;;OAEG;IAEG,OAAO;CAMhB;AAED,gBAAgB;AAChB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkB5B,CAAC"}

package/dist/CameraKit.js

@@ -19,6 +19,7 @@ import { errorLoggingDecorator } from "./logger/errorLoggingDecorator";
 import { TypedEventTarget } from "./events/TypedEventTarget";
 import { pageVisibilityFactory } from "./common/pageVisibility";
 import { setPreloadedConfiguration } from "./remote-configuration/preloadConfiguration";
+import { getTrustedTypesHandler } from "./trusted-types/trustedTypesHandler";
 import { remoteConfigurationFactory } from "./remote-configuration/remoteConfiguration";
 import { registerGeoDataProvider } from "./geo/registerGeoDataProvider";
 import { frameEventsFactory } from "./session/frameEvents";
@@ -56,10 +57,16 @@ export let CameraKit = (() => {
                         }
                     };
                     const config = this.container.get(configurationToken);
+                    const trustedTypesHandler = getTrustedTypesHandler(config.trustedTypesPolicyName);
                     yield this.lensCore.initialize({
                         canvas: liveRenderTarget,
                         shouldUseWorker: !renderWhileTabHidden && config.shouldUseWorker,
                         exceptionHandler,
+                        trustedTypes: {
+                            policyName: trustedTypesHandler.policyName,
+                            getTrustedUrls: trustedTypesHandler.getTrustedUrls,
+                            trustUrl: trustedTypesHandler.trustUrl,
+                        },
                     });
                     if (this.lensCore.setGpuIndex) {
                         try {

package/dist/CameraKit.js.map

@@ -1 +1 @@
-{"version":3,"file":"CameraKit.js","sourceRoot":"","sources":["../src/CameraKit.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Container } from \"@snap/ts-inject\";\nimport { CONTAINER, Injectable } from \"@snap/ts-inject\";\nimport { firstValueFrom } from \"rxjs\";\nimport type { LensRepository } from \"./lens/LensRepository\";\nimport { lensRepositoryFactory } from \"./lens/LensRepository\";\nimport type { LensCoreError } from \"./lens-core-module/lensCoreError\";\nimport type { LensCore } from \"./lens-core-module/lensCore\";\nimport type { CameraKitSession } from \"./session/CameraKitSession\";\nimport { cameraKitSessionFactory } from \"./session/CameraKitSession\";\nimport { registerLensAssetsProvider } from \"./lens/assets/LensAssetsProvider\";\nimport { lensCoreFactory } from \"./lens-core-module/loader/lensCoreFactory\";\nimport { configurationToken } from \"./configuration\";\nimport type { RootServices } from \"./RootServices\";\nimport { registerUriHandlers } from \"./uri-handlers/uriHandlersRegister\";\nimport type { MetricsEventTarget } from \"./metrics/metricsEventTarget\";\nimport { metricsEventTargetFactory } from \"./metrics/metricsEventTarget\";\nimport { reportSessionScopedMetrics } from \"./metrics/reporters/reporters\";\nimport { lensStateFactory } from \"./session/lensState\";\nimport { lensKeyboardFactory } from \"./session/LensKeyboard\";\nimport { registerLensClientInterfaceHandler } from \"./lens-client-interface/lensClientInterface\";\nimport { sessionStateFactory } from \"./session/sessionState\";\nimport { lensExecutionError, lensAbortError } from \"./namedErrors\";\nimport { getLogger, resetLogger } from \"./logger/logger\";\nimport { errorLoggingDecorator } from \"./logger/errorLoggingDecorator\";\nimport { TypedEventTarget } from \"./events/TypedEventTarget\";\nimport type { TypedCustomEvent } from \"./events/TypedCustomEvent\";\nimport type { LensView } from \"./metrics/reporters/reportLensView\";\nimport type { LensWait } from \"./metrics/reporters/reportLensWait\";\nimport type { PageVisibility } from \"./common/pageVisibility\";\nimport { pageVisibilityFactory } from \"./common/pageVisibility\";\nimport { setPreloadedConfiguration } from \"./remote-configuration/preloadConfiguration\";\nimport type { RemoteConfiguration } from \"./remote-configuration/remoteConfiguration\";\nimport { remoteConfigurationFactory } from \"./remote-configuration/remoteConfiguration\";\nimport { registerGeoDataProvider } from \"./geo/registerGeoDataProvider\";\nimport { frameEventsFactory } from \"./session/frameEvents\";\n\nconst logger = getLogger(\"CameraKit\");\n\n/**\n * Metrics event names that are exposed to apps.\n */\nconst publicMetricsEventNames: Array<LensMetricsEvents[\"detail\"][\"name\"]> = [\"lensView\", \"lensWait\"];\n\n/**\n * Lens metrics events.\n *\n * These events are emitted by {@link CameraKit} to report lens usage, performance, apply latency, etc.\n *\n * @category Lenses\n * @category Metrics\n */\nexport type LensMetricsEvents =\n    | TypedCustomEvent<LensView[\"name\"], LensView>\n    | TypedCustomEvent<LensWait[\"name\"], LensWait>;\n\n/**\n * Options available when creating a {@link CameraKitSession}.\n *\n * @category Rendering\n */\nexport interface CreateSessionOptions {\n    /**\n     * Optionally provide an existing canvas element, on which the Live RenderTarget will be rendered.\n     *\n     * If this is not provided, CameraKit will create a new canvas element which can be added to the DOM.\n     */\n    liveRenderTarget?: HTMLCanvasElement;\n\n    /**\n     * Browsers optimize tabs when they are hidden - for example, by pausing the execution of requestAnimationFrame\n     * callbacks.\n     *\n     * If you need the CameraKitSession to continue rendering even when the tab is in the background, set this to true.\n     * There is a small performance penalty, and it's a good practice to only render in the background if absolutely\n     * necessary.\n     */\n    renderWhileTabHidden?: boolean;\n}\n\n/**\n * The entry point to the CameraKit SDK's API. Most of CameraKit's features are accessed via this class.\n *\n * Applications obtain an instance of CameraKit by calling {@link bootstrapCameraKit}.\n *\n * @example\n * ```ts\n * const cameraKit = await bootstrapCameraKit(config)\n * ```\n *\n * Then this class can be used to:\n * - Create a {@link CameraKitSession} instance, which provides the API for setting up media inputs, applying Lenses,\n * and obtaining rendered `<canvas>` outputs.\n * - Query for lenses using {@link LensRepository}.\n * - Listen for lens usage metrics events using {@link MetricsEventTarget}.\n *\n * @category Rendering\n * @category Lenses\n */\nexport class CameraKit {\n    /** @deprecated Use {@link lensRepository} */\n    readonly lenses: { repository: LensRepository };\n\n    /**\n     * Business metrics (e.g. each time a lens is viewed) are emitted here.\n     */\n    readonly metrics: TypedEventTarget<LensMetricsEvents> = new TypedEventTarget();\n\n    private sessions: CameraKitSession[] = [];\n\n    /** @internal */\n    constructor(\n        /**\n         * Used to query for lenses and lens groups.\n         */\n        readonly lensRepository: LensRepository,\n\n        private readonly lensCore: LensCore,\n        private readonly pageVisibility: PageVisibility,\n        private readonly container: Container<RootServices>,\n        private readonly remoteConfig: RemoteConfiguration,\n        allMetrics: MetricsEventTarget\n    ) {\n        this.lenses = { repository: this.lensRepository };\n        // Proxy only a subset of all metrics events to the public-facing emitter -- applications don't need to\n        // know about most events.\n        publicMetricsEventNames.forEach((eventName) => {\n            allMetrics.addEventListener(eventName, (e) => this.metrics.dispatchEvent(e));\n        });\n    }\n\n    /**\n     * Create a CameraKitSession.\n     *\n     * This initializes the rendering engine and returns a {@link CameraKitSession} instance, which provides access\n     * to Lens rendering.\n     *\n     * @example\n     * ```ts\n     * const cameraKit = await bootstrapCameraKit(config)\n     * const session = await cameraKit.createSession()\n     *\n     * const lens = await cameraKit.lensRepository.loadLens(lensId, groupId)\n     * session.applyLens(lens)\n     * ```\n     *\n     * @param options\n     */\n    @errorLoggingDecorator(logger)\n    async createSession({\n        liveRenderTarget,\n        renderWhileTabHidden,\n    }: CreateSessionOptions = {}): Promise<CameraKitSession> {\n        // Any error happened during lens rendering can be processed by subscribing to sessionErrors\n        const exceptionHandler = (error: LensCoreError) => {\n            if (error.name === \"LensCoreAbortError\") {\n                logger.error(\n                    lensAbortError(\n                        \"Unrecoverable error occurred during lens execution. \" +\n                            \"The CameraKitSession will be destroyed.\",\n                        error\n                    )\n                );\n            } else {\n                logger.error(\n                    lensExecutionError(\n                        \"Error occurred during lens execution. \" +\n                            \"The lens cannot be rendered and will be removed from the CameraKitSession.\",\n                        error\n                    )\n                );\n            }\n        };\n\n        const config = this.container.get(configurationToken);\n\n        /**\n         * If/when we add support for multiple concurrent sessions, we'll need to create a copy of the LensCore WASM\n         * module. If we move managing web workers into JS, spawning a new worker thread with its own copy of LensCore\n         * probably becomes a lot more straightforward.\n         *\n         * Currently chromium has a bug preventing rendering while tab is hidden when LensCore is in worker mode.\n         * In order to process tab while it is hidden, the current stopgap is to pass in renderWhileTabHidden as true,\n         * which will initiate session in non worker mode, and set the RenderLoopMode to `SetTimeout`.\n         */\n        await this.lensCore.initialize({\n            canvas: liveRenderTarget,\n            shouldUseWorker: !renderWhileTabHidden && config.shouldUseWorker,\n            exceptionHandler,\n        });\n\n        if (this.lensCore.setGpuIndex) {\n            // NOTE: setGpuIndex was added in LensCore@292. This check ensures compatibility with older versions.\n\n            // Camera Kit allows a performance cluster to be provided during bootstrap.\n            // This cluster is passed to the LENS_FEATURE_GPU_INDEX config as LENS_CLUSTER_ORIG_4,\n            // which maps the cluster to a GPU index.\n            try {\n                await this.lensCore.setGpuIndex({\n                    gpuIndex: await firstValueFrom(this.remoteConfig.getGpuIndexConfig()),\n                });\n            } catch (cause) {\n                // LensCore initialization can proceed without the GPU index,\n                // as it is mainly needed for ML lenses.\n                logger.error(new Error(\"Cannot set GPU index.\", { cause }));\n            }\n        }\n\n        if (config.fonts.length > 0) {\n            this.lensCore.setSystemFonts({\n                fonts: config.fonts,\n            });\n        }\n\n        await this.lensCore.setRenderLoopMode({\n            mode: renderWhileTabHidden\n                ? this.lensCore.RenderLoopMode.SetTimeout\n                : this.lensCore.RenderLoopMode.RequestAnimationFrame,\n        });\n\n        // Each session gets its own DI Container – some Services provided by this Container may be shared with the\n        // root CameraKit Container, but others may be scoped to the session by passing their token to `copy()`.\n        const sessionContainer = this.container\n            // Right now this is a no-op. If/when we add support for multiple concurrent sessions, we may end up\n            // scoping LensCore to the session.\n            .copy()\n\n            .provides(sessionStateFactory)\n            .provides(lensStateFactory)\n            .provides(lensKeyboardFactory)\n            .provides(frameEventsFactory)\n            .provides(cameraKitSessionFactory)\n\n            .run(registerLensAssetsProvider)\n            .run(registerLensClientInterfaceHandler)\n            .run(registerGeoDataProvider)\n            .run(setPreloadedConfiguration)\n\n            // We'll run a PartialContainer containing reporters for session-scoped metrics. Running this container\n            // allows each metric reporter to initialize itself (e.g. by adding event listeners to detect when certain\n            // actions occur).\n            .run(reportSessionScopedMetrics)\n\n            // UriHandlers may have dependencies on session-scoped services (e.g. LensState, LensKeyboard), so they'll\n            // be registered with LensCore here.\n            .run(registerUriHandlers);\n\n        const session = sessionContainer.get(cameraKitSessionFactory.token);\n        this.sessions.push(session);\n        return session;\n    }\n\n    /**\n     * Destroys all sessions and frees all resources.\n     */\n    @errorLoggingDecorator(logger)\n    async destroy() {\n        resetLogger();\n        this.pageVisibility.destroy();\n        await Promise.all(this.sessions.map((session) => session.destroy()));\n        this.sessions = [];\n    }\n}\n\n/** @internal */\nexport const cameraKitFactory = Injectable(\n    \"CameraKit\",\n    [\n        lensRepositoryFactory.token,\n        metricsEventTargetFactory.token,\n        lensCoreFactory.token,\n        pageVisibilityFactory.token,\n        remoteConfigurationFactory.token,\n        CONTAINER,\n    ] as const,\n    (\n        lensRepository: LensRepository,\n        metrics: MetricsEventTarget,\n        lensCore: LensCore,\n        pageVisibility: PageVisibility,\n        remoteConfiguration: RemoteConfiguration,\n        container: Container<RootServices>\n    ) => new CameraKit(lensRepository, lensCore, pageVisibility, container, remoteConfiguration, metrics)\n);\n"]}
+{"version":3,"file":"CameraKit.js","sourceRoot":"","sources":["../src/CameraKit.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Container } from \"@snap/ts-inject\";\nimport { CONTAINER, Injectable } from \"@snap/ts-inject\";\nimport { firstValueFrom } from \"rxjs\";\nimport type { LensRepository } from \"./lens/LensRepository\";\nimport { lensRepositoryFactory } from \"./lens/LensRepository\";\nimport type { LensCoreError } from \"./lens-core-module/lensCoreError\";\nimport type { LensCore } from \"./lens-core-module/lensCore\";\nimport type { CameraKitSession } from \"./session/CameraKitSession\";\nimport { cameraKitSessionFactory } from \"./session/CameraKitSession\";\nimport { registerLensAssetsProvider } from \"./lens/assets/LensAssetsProvider\";\nimport { lensCoreFactory } from \"./lens-core-module/loader/lensCoreFactory\";\nimport { configurationToken } from \"./configuration\";\nimport type { RootServices } from \"./RootServices\";\nimport { registerUriHandlers } from \"./uri-handlers/uriHandlersRegister\";\nimport type { MetricsEventTarget } from \"./metrics/metricsEventTarget\";\nimport { metricsEventTargetFactory } from \"./metrics/metricsEventTarget\";\nimport { reportSessionScopedMetrics } from \"./metrics/reporters/reporters\";\nimport { lensStateFactory } from \"./session/lensState\";\nimport { lensKeyboardFactory } from \"./session/LensKeyboard\";\nimport { registerLensClientInterfaceHandler } from \"./lens-client-interface/lensClientInterface\";\nimport { sessionStateFactory } from \"./session/sessionState\";\nimport { lensExecutionError, lensAbortError } from \"./namedErrors\";\nimport { getLogger, resetLogger } from \"./logger/logger\";\nimport { errorLoggingDecorator } from \"./logger/errorLoggingDecorator\";\nimport { TypedEventTarget } from \"./events/TypedEventTarget\";\nimport type { TypedCustomEvent } from \"./events/TypedCustomEvent\";\nimport type { LensView } from \"./metrics/reporters/reportLensView\";\nimport type { LensWait } from \"./metrics/reporters/reportLensWait\";\nimport type { PageVisibility } from \"./common/pageVisibility\";\nimport { pageVisibilityFactory } from \"./common/pageVisibility\";\nimport { setPreloadedConfiguration } from \"./remote-configuration/preloadConfiguration\";\nimport type { RemoteConfiguration } from \"./remote-configuration/remoteConfiguration\";\nimport { getTrustedTypesHandler } from \"./trusted-types/trustedTypesHandler\";\nimport { remoteConfigurationFactory } from \"./remote-configuration/remoteConfiguration\";\nimport { registerGeoDataProvider } from \"./geo/registerGeoDataProvider\";\nimport { frameEventsFactory } from \"./session/frameEvents\";\n\nconst logger = getLogger(\"CameraKit\");\n\n/**\n * Metrics event names that are exposed to apps.\n */\nconst publicMetricsEventNames: Array<LensMetricsEvents[\"detail\"][\"name\"]> = [\"lensView\", \"lensWait\"];\n\n/**\n * Lens metrics events.\n *\n * These events are emitted by {@link CameraKit} to report lens usage, performance, apply latency, etc.\n *\n * @category Lenses\n * @category Metrics\n */\nexport type LensMetricsEvents =\n    | TypedCustomEvent<LensView[\"name\"], LensView>\n    | TypedCustomEvent<LensWait[\"name\"], LensWait>;\n\n/**\n * Options available when creating a {@link CameraKitSession}.\n *\n * @category Rendering\n */\nexport interface CreateSessionOptions {\n    /**\n     * Optionally provide an existing canvas element, on which the Live RenderTarget will be rendered.\n     *\n     * If this is not provided, CameraKit will create a new canvas element which can be added to the DOM.\n     */\n    liveRenderTarget?: HTMLCanvasElement;\n\n    /**\n     * Browsers optimize tabs when they are hidden - for example, by pausing the execution of requestAnimationFrame\n     * callbacks.\n     *\n     * If you need the CameraKitSession to continue rendering even when the tab is in the background, set this to true.\n     * There is a small performance penalty, and it's a good practice to only render in the background if absolutely\n     * necessary.\n     */\n    renderWhileTabHidden?: boolean;\n}\n\n/**\n * The entry point to the CameraKit SDK's API. Most of CameraKit's features are accessed via this class.\n *\n * Applications obtain an instance of CameraKit by calling {@link bootstrapCameraKit}.\n *\n * @example\n * ```ts\n * const cameraKit = await bootstrapCameraKit(config)\n * ```\n *\n * Then this class can be used to:\n * - Create a {@link CameraKitSession} instance, which provides the API for setting up media inputs, applying Lenses,\n * and obtaining rendered `<canvas>` outputs.\n * - Query for lenses using {@link LensRepository}.\n * - Listen for lens usage metrics events using {@link MetricsEventTarget}.\n *\n * @category Rendering\n * @category Lenses\n */\nexport class CameraKit {\n    /** @deprecated Use {@link lensRepository} */\n    readonly lenses: { repository: LensRepository };\n\n    /**\n     * Business metrics (e.g. each time a lens is viewed) are emitted here.\n     */\n    readonly metrics: TypedEventTarget<LensMetricsEvents> = new TypedEventTarget();\n\n    private sessions: CameraKitSession[] = [];\n\n    /** @internal */\n    constructor(\n        /**\n         * Used to query for lenses and lens groups.\n         */\n        readonly lensRepository: LensRepository,\n\n        private readonly lensCore: LensCore,\n        private readonly pageVisibility: PageVisibility,\n        private readonly container: Container<RootServices>,\n        private readonly remoteConfig: RemoteConfiguration,\n        allMetrics: MetricsEventTarget\n    ) {\n        this.lenses = { repository: this.lensRepository };\n        // Proxy only a subset of all metrics events to the public-facing emitter -- applications don't need to\n        // know about most events.\n        publicMetricsEventNames.forEach((eventName) => {\n            allMetrics.addEventListener(eventName, (e) => this.metrics.dispatchEvent(e));\n        });\n    }\n\n    /**\n     * Create a CameraKitSession.\n     *\n     * This initializes the rendering engine and returns a {@link CameraKitSession} instance, which provides access\n     * to Lens rendering.\n     *\n     * @example\n     * ```ts\n     * const cameraKit = await bootstrapCameraKit(config)\n     * const session = await cameraKit.createSession()\n     *\n     * const lens = await cameraKit.lensRepository.loadLens(lensId, groupId)\n     * session.applyLens(lens)\n     * ```\n     *\n     * @param options\n     */\n    @errorLoggingDecorator(logger)\n    async createSession({\n        liveRenderTarget,\n        renderWhileTabHidden,\n    }: CreateSessionOptions = {}): Promise<CameraKitSession> {\n        // Any error happened during lens rendering can be processed by subscribing to sessionErrors\n        const exceptionHandler = (error: LensCoreError) => {\n            if (error.name === \"LensCoreAbortError\") {\n                logger.error(\n                    lensAbortError(\n                        \"Unrecoverable error occurred during lens execution. \" +\n                            \"The CameraKitSession will be destroyed.\",\n                        error\n                    )\n                );\n            } else {\n                logger.error(\n                    lensExecutionError(\n                        \"Error occurred during lens execution. \" +\n                            \"The lens cannot be rendered and will be removed from the CameraKitSession.\",\n                        error\n                    )\n                );\n            }\n        };\n\n        const config = this.container.get(configurationToken);\n\n        /**\n         * If/when we add support for multiple concurrent sessions, we'll need to create a copy of the LensCore WASM\n         * module. If we move managing web workers into JS, spawning a new worker thread with its own copy of LensCore\n         * probably becomes a lot more straightforward.\n         *\n         * Currently chromium has a bug preventing rendering while tab is hidden when LensCore is in worker mode.\n         * In order to process tab while it is hidden, the current stopgap is to pass in renderWhileTabHidden as true,\n         * which will initiate session in non worker mode, and set the RenderLoopMode to `SetTimeout`.\n         */\n        const trustedTypesHandler = getTrustedTypesHandler(config.trustedTypesPolicyName);\n        await this.lensCore.initialize({\n            canvas: liveRenderTarget,\n            shouldUseWorker: !renderWhileTabHidden && config.shouldUseWorker,\n            exceptionHandler,\n            trustedTypes: {\n                policyName: trustedTypesHandler.policyName,\n                getTrustedUrls: trustedTypesHandler.getTrustedUrls,\n                trustUrl: trustedTypesHandler.trustUrl,\n            },\n        });\n\n        if (this.lensCore.setGpuIndex) {\n            // NOTE: setGpuIndex was added in LensCore@292. This check ensures compatibility with older versions.\n\n            // Camera Kit allows a performance cluster to be provided during bootstrap.\n            // This cluster is passed to the LENS_FEATURE_GPU_INDEX config as LENS_CLUSTER_ORIG_4,\n            // which maps the cluster to a GPU index.\n            try {\n                await this.lensCore.setGpuIndex({\n                    gpuIndex: await firstValueFrom(this.remoteConfig.getGpuIndexConfig()),\n                });\n            } catch (cause) {\n                // LensCore initialization can proceed without the GPU index,\n                // as it is mainly needed for ML lenses.\n                logger.error(new Error(\"Cannot set GPU index.\", { cause }));\n            }\n        }\n\n        if (config.fonts.length > 0) {\n            this.lensCore.setSystemFonts({\n                fonts: config.fonts,\n            });\n        }\n\n        await this.lensCore.setRenderLoopMode({\n            mode: renderWhileTabHidden\n                ? this.lensCore.RenderLoopMode.SetTimeout\n                : this.lensCore.RenderLoopMode.RequestAnimationFrame,\n        });\n\n        // Each session gets its own DI Container – some Services provided by this Container may be shared with the\n        // root CameraKit Container, but others may be scoped to the session by passing their token to `copy()`.\n        const sessionContainer = this.container\n            // Right now this is a no-op. If/when we add support for multiple concurrent sessions, we may end up\n            // scoping LensCore to the session.\n            .copy()\n\n            .provides(sessionStateFactory)\n            .provides(lensStateFactory)\n            .provides(lensKeyboardFactory)\n            .provides(frameEventsFactory)\n            .provides(cameraKitSessionFactory)\n\n            .run(registerLensAssetsProvider)\n            .run(registerLensClientInterfaceHandler)\n            .run(registerGeoDataProvider)\n            .run(setPreloadedConfiguration)\n\n            // We'll run a PartialContainer containing reporters for session-scoped metrics. Running this container\n            // allows each metric reporter to initialize itself (e.g. by adding event listeners to detect when certain\n            // actions occur).\n            .run(reportSessionScopedMetrics)\n\n            // UriHandlers may have dependencies on session-scoped services (e.g. LensState, LensKeyboard), so they'll\n            // be registered with LensCore here.\n            .run(registerUriHandlers);\n\n        const session = sessionContainer.get(cameraKitSessionFactory.token);\n        this.sessions.push(session);\n        return session;\n    }\n\n    /**\n     * Destroys all sessions and frees all resources.\n     */\n    @errorLoggingDecorator(logger)\n    async destroy() {\n        resetLogger();\n        this.pageVisibility.destroy();\n        await Promise.all(this.sessions.map((session) => session.destroy()));\n        this.sessions = [];\n    }\n}\n\n/** @internal */\nexport const cameraKitFactory = Injectable(\n    \"CameraKit\",\n    [\n        lensRepositoryFactory.token,\n        metricsEventTargetFactory.token,\n        lensCoreFactory.token,\n        pageVisibilityFactory.token,\n        remoteConfigurationFactory.token,\n        CONTAINER,\n    ] as const,\n    (\n        lensRepository: LensRepository,\n        metrics: MetricsEventTarget,\n        lensCore: LensCore,\n        pageVisibility: PageVisibility,\n        remoteConfiguration: RemoteConfiguration,\n        container: Container<RootServices>\n    ) => new CameraKit(lensRepository, lensCore, pageVisibility, container, remoteConfiguration, metrics)\n);\n"]}

package/dist/common/loadScript.d.ts

@@ -1,7 +1,8 @@
+/// <reference types="trusted-types" />
 /**
  * Adds script element to document body and starts downloading provided script URL.
  * @param scriptUri Script URL.
  * @returns Script element added.
  */
-export declare function loadScript(scriptUri: string): Promise<HTMLScriptElement>;
+export declare function loadScript(scriptUri: string | TrustedScriptURL): Promise<HTMLScriptElement>;
 //# sourceMappingURL=loadScript.d.ts.map

package/dist/common/loadScript.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadScript.d.ts","sourceRoot":"","sources":["../../src/common/loadScript.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAaxE"}
+{"version":3,"file":"loadScript.d.ts","sourceRoot":"","sources":["../../src/common/loadScript.ts"],"names":[],"mappings":";AAEA;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAc3F"}

package/dist/common/loadScript.js.map

@@ -1 +1 @@
-{"version":3,"file":"loadScript.js","sourceRoot":"","sources":["../../src/common/loadScript.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAOnD,MAAM,UAAU,UAAU,CAAC,SAAiB;IACxC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACnC,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACvD,aAAa,CAAC,GAAG,GAAG,SAAS,CAAC;QAC9B,aAAa,CAAC,KAAK,GAAG,IAAI,CAAC;QAC3B,KAAK,CACD,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,EACxE,SAAS,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAChE;aACI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACb,SAAS,EAAE,CAAC;QACjB,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;AACP,CAAC","sourcesContent":["import { fromEvent, merge, take, tap } from \"rxjs\";\n\n/**\n * Adds script element to document body and starts downloading provided script URL.\n * @param scriptUri Script URL.\n * @returns Script element added.\n */\nexport function loadScript(scriptUri: string): Promise<HTMLScriptElement> {\n    return new Promise((resolve, reject) => {\n        const scriptElement = document.createElement(\"script\");\n        scriptElement.src = scriptUri;\n        scriptElement.async = true;\n        merge(\n            fromEvent(scriptElement, \"load\").pipe(tap(() => resolve(scriptElement))),\n            fromEvent(scriptElement, \"error\").pipe(tap((e) => reject(e)))\n        )\n            .pipe(take(1))\n            .subscribe();\n        document.body.appendChild(scriptElement);\n    });\n}\n"]}
+{"version":3,"file":"loadScript.js","sourceRoot":"","sources":["../../src/common/loadScript.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAOnD,MAAM,UAAU,UAAU,CAAC,SAAoC;IAC3D,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACnC,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAEvD,aAAa,CAAC,GAAG,GAAG,SAAmB,CAAC;QACxC,aAAa,CAAC,KAAK,GAAG,IAAI,CAAC;QAC3B,KAAK,CACD,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,EACxE,SAAS,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAChE;aACI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACb,SAAS,EAAE,CAAC;QACjB,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;AACP,CAAC","sourcesContent":["import { fromEvent, merge, take, tap } from \"rxjs\";\n\n/**\n * Adds script element to document body and starts downloading provided script URL.\n * @param scriptUri Script URL.\n * @returns Script element added.\n */\nexport function loadScript(scriptUri: string | TrustedScriptURL): Promise<HTMLScriptElement> {\n    return new Promise((resolve, reject) => {\n        const scriptElement = document.createElement(\"script\");\n        // Safety: TrustedScriptURL is safe to assign to script.src\n        scriptElement.src = scriptUri as string;\n        scriptElement.async = true;\n        merge(\n            fromEvent(scriptElement, \"load\").pipe(tap(() => resolve(scriptElement))),\n            fromEvent(scriptElement, \"error\").pipe(tap((e) => reject(e)))\n        )\n            .pipe(take(1))\n            .subscribe();\n        document.body.appendChild(scriptElement);\n    });\n}\n"]}

package/dist/configuration.d.ts

@@ -1,15 +1,16 @@
 import type { EstimatedLensPerformance } from "./benchmark/estimateLensPerformanceCluster";
 import type { Lens } from "./lens/Lens";
-import type { LogLevelName } from "./logger/logger";
+import { type Logger, type LogLevel } from "./logger/logger";
 interface CameraKitRuntimeConfiguration {
     lensPerformance: EstimatedLensPerformance | Promise<EstimatedLensPerformance>;
-    logger: "noop" | "console";
-    logLevel: LogLevelName;
+    logger: Logger;
+    logLevel: LogLevel;
     shouldUseWorker: boolean;
     apiHostname: CameraKitApiHostname;
     userAgentFlavor: "release" | "debug";
     fonts: Font[];
     lensHttpHandler?: LensHttpHandler;
+    trustedTypesPolicyName: string;
 }
 export type CameraKitApiHostname = "camera-kit-api.snapar.com" | "api-kit.snapchat.com";
 /**
@@ -86,17 +87,17 @@ export interface CameraKitBootstrapConfiguration {
      * Determine where to print CameraKit log messages. By default no logs will be printed.
      *
      * CameraKit emits log messages to help diagnose and root cause issues that may occur during the development of a
-     * host application. The printing of these can be controlled via the following
-     * options:
-     *  - `noop`: log messages are ignored.
-     *  - `console`: log messages are printed to console.
+     * host application. The printing of these can be controlled via the following options:
+     *  - `"noop"`: log messages are ignored.
+     *  - `"console"`: log messages are printed to console.
+     *  - A custom {@link Logger} instance can be provided to integrate with an existing logging system.
      */
-    logger?: "noop" | "console";
+    logger?: "noop" | "console" | Logger;
     /**
      * Log only if a logged entry level is greater than or equal to this level. Here is the order of levels:
      * error > warn > log = info > debug. Default value is "info".
      */
-    logLevel?: LogLevelName;
+    logLevel?: LogLevel;
     /**
      * Some lenses may decide to modify their behavior based on the performance of the current environment. If you are
      * using such lenses, providing an estimation of lens performance may lead to better user experience (especially on
@@ -197,6 +198,11 @@ export interface CameraKitBootstrapConfiguration {
      * ```
      */
     lensHttpHandler?: LensHttpHandler;
+    /**
+     * The name of the Trusted Types policy to use when loading scripts.
+     * Defaults to "snap-camera-kit".
+     */
+    trustedTypesPolicyName?: string;
 }
 /**
  * This type represents the result of merging user-supplied config with default config -- as such, it has no nullable

package/dist/configuration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configuration.d.ts","sourceRoot":"","sources":["../src/configuration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AAG3F,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AA0BpD,UAAU,6BAA6B;IACnC,eAAe,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC9E,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,QAAQ,EAAE,YAAY,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,oBAAoB,CAAC;IAClC,eAAe,EAAE,SAAS,GAAG,OAAO,CAAC;IACrC,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,eAAe,CAAC,EAAE,eAAe,CAAC;CACrC;AAED,MAAM,MAAM,oBAAoB,GAAG,2BAA2B,GAAG,sBAAsB,CAAC;AAExF;;GAEG;AACH,MAAM,WAAW,IAAI;IACjB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,WAAW,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC5B;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,IAAI,EAAE,WAAW,CAAC;IAElB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhC;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;CACd;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,eAAe,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAElH;;;;;GAKG;AACH,MAAM,WAAW,+BAA+B;IAC5C;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,CAAC,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAE/E;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IAEpD;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IAEf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;CACrC;AAED;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG,6BAA6B,GAAG,+BAA+B,CAAC;AAErG,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAelD,gBAAgB;AAChB,eAAO,MAAM,mCAAmC,kBAAmB,+BAA+B;;;;CA0BjG,CAAC"}
+{"version":3,"file":"configuration.d.ts","sourceRoot":"","sources":["../src/configuration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AAG3F,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAyB,KAAK,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AA2BpF,UAAU,6BAA6B;IACnC,eAAe,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,oBAAoB,CAAC;IAClC,eAAe,EAAE,SAAS,GAAG,OAAO,CAAC;IACrC,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,sBAAsB,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,MAAM,oBAAoB,GAAG,2BAA2B,GAAG,sBAAsB,CAAC;AAExF;;GAEG;AACH,MAAM,WAAW,IAAI;IACjB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,WAAW,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC5B;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,IAAI,EAAE,WAAW,CAAC;IAElB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhC;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;CACd;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,eAAe,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAElH;;;;;GAKG;AACH,MAAM,WAAW,+BAA+B;IAC5C;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;IAErC;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,CAAC,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAE/E;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IAEpD;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IAEf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;IAElC;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG,6BAA6B,GAAG,+BAA+B,CAAC;AAErG,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAelD,gBAAgB;AAChB,eAAO,MAAM,mCAAmC,kBAAmB,+BAA+B;;;;CA2BjG,CAAC"}

package/dist/configuration.js

@@ -1,14 +1,16 @@
 import { Injectable } from "@snap/ts-inject";
 import { copyDefinedProperties } from "./common/copyDefinedProperties";
 import { getConfigurationOverrides } from "./configurationOverrides";
+import { mapLogger, noopLogger } from "./logger/logger";
 const defaultConfiguration = {
     lensPerformance: { cluster: 0, benchmarks: [], webglRendererInfo: "unknown" },
-    logger: "noop",
+    logger: noopLogger,
     logLevel: "info",
     shouldUseWorker: true,
     apiHostname: "camera-kit-api.snapar.com",
     userAgentFlavor: "release",
     fonts: [],
+    trustedTypesPolicyName: "snap-camera-kit",
 };
 export const configurationToken = "configuration";
 function isHandledAppleDevice() {
@@ -21,11 +23,12 @@ export const createCameraKitConfigurationFactory = (configuration) => {
         console.warn("Configuration overrides applied", overrides);
     }
     return Injectable(configurationToken, () => {
+        var _a;
         const safeConfig = Object.assign(Object.assign({}, configuration), { lensPerformance: configuration.lensPerformance instanceof Promise
                 ?
                     configuration.lensPerformance.catch(() => defaultConfiguration.lensPerformance)
                 : configuration.lensPerformance });
-        return Object.assign(Object.assign(Object.assign(Object.assign({}, defaultConfiguration), { shouldUseWorker: isHandledAppleDevice() ? false : defaultConfiguration.shouldUseWorker }), copyDefinedProperties(safeConfig)), copyDefinedProperties(overrides !== null && overrides !== void 0 ? overrides : {}));
+        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, defaultConfiguration), { shouldUseWorker: isHandledAppleDevice() ? false : defaultConfiguration.shouldUseWorker }), copyDefinedProperties(safeConfig)), copyDefinedProperties(overrides !== null && overrides !== void 0 ? overrides : {})), { logger: mapLogger((_a = safeConfig.logger) !== null && _a !== void 0 ? _a : overrides === null || overrides === void 0 ? void 0 : overrides.logger) });
     });
 };
 //# sourceMappingURL=configuration.js.map

package/dist/configuration.js.map

@@ -1 +1 @@
-{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../src/configuration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAerE,MAAM,oBAAoB,GAAmF;IAIzG,eAAe,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,iBAAiB,EAAE,SAAS,EAAE;IAC7E,MAAM,EAAE,MAAM;IACd,QAAQ,EAAE,MAAM;IAChB,eAAe,EAAE,IAAI;IACrB,WAAW,EAAE,2BAA2B;IACxC,eAAe,EAAE,SAAS;IAC1B,KAAK,EAAE,EAAE;CACZ,CAAC;AAiOF,MAAM,CAAC,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAKlD,SAAS,oBAAoB;IAIzB,OAAO,CACH,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;QAC3C,CAAC,SAAS,CAAC,QAAQ,KAAK,UAAU,IAAI,SAAS,CAAC,cAAc,GAAG,CAAC,CAAC,CACtE,CAAC;AACN,CAAC;AAGD,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,aAA8C,EAAE,EAAE;IAElG,MAAM,SAAS,GAAG,yBAAyB,EAAE,CAAC;IAC9C,IAAI,SAAS,EAAE;QACX,OAAO,CAAC,IAAI,CAAC,iCAAiC,EAAE,SAAS,CAAC,CAAC;KAC9D;IACD,OAAO,UAAU,CAAC,kBAAkB,EAAE,GAA2B,EAAE;QAG/D,MAAM,UAAU,mCACT,aAAa,KAChB,eAAe,EACX,aAAa,CAAC,eAAe,YAAY,OAAO;gBAC5C,CAAC;oBACC,aAAa,CAAC,eAAe,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,oBAAoB,CAAC,eAAgB,CAAC;gBAClF,CAAC,CAAC,aAAa,CAAC,eAAe,GAC1C,CAAC;QACF,mEACO,oBAAoB,KAGvB,eAAe,EAAE,oBAAoB,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,oBAAoB,CAAC,eAAe,KACnF,qBAAqB,CAAC,UAAU,CAAC,GACjC,qBAAqB,CAAC,SAAS,aAAT,SAAS,cAAT,SAAS,GAAI,EAAE,CAAC,EAC3C;IACN,CAAC,CAAC,CAAC;AACP,CAAC,CAAC","sourcesContent":["import { Injectable } from \"@snap/ts-inject\";\nimport type { EstimatedLensPerformance } from \"./benchmark/estimateLensPerformanceCluster\";\nimport { copyDefinedProperties } from \"./common/copyDefinedProperties\";\nimport { getConfigurationOverrides } from \"./configurationOverrides\";\nimport type { Lens } from \"./lens/Lens\";\nimport type { LogLevelName } from \"./logger/logger\";\n\n/**\n * From T, pick the set of properties whose values are optional. Create a new type containing only those properties.\n */\ntype PickOptionals<T> = {\n    [K in keyof T as T[K] extends Exclude<T[K], undefined> ? never : K]: T[K];\n};\n\n/**\n * Defaults are provided for runtime configuration and any optional bootstrap configuration properties which require\n * defaults.\n */\nconst defaultConfiguration: CameraKitRuntimeConfiguration & PickOptionals<CameraKitBootstrapConfiguration> = {\n    // If the applications doesn't provide performance data (e.g. via estimateLensPerformance), we'll use 0 to indicate\n    // no performance estimation occurred. This is indicative of typical performance-targeting logic, which often\n    // defaults to the lowest-tier experience in the absence of performance cluster data.\n    lensPerformance: { cluster: 0, benchmarks: [], webglRendererInfo: \"unknown\" },\n    logger: \"noop\",\n    logLevel: \"info\",\n    shouldUseWorker: true,\n    apiHostname: \"camera-kit-api.snapar.com\",\n    userAgentFlavor: \"release\",\n    fonts: [],\n};\n\ninterface CameraKitRuntimeConfiguration {\n    lensPerformance: EstimatedLensPerformance | Promise<EstimatedLensPerformance>;\n    logger: \"noop\" | \"console\";\n    logLevel: LogLevelName;\n    shouldUseWorker: boolean;\n    apiHostname: CameraKitApiHostname;\n    userAgentFlavor: \"release\" | \"debug\";\n    fonts: Font[];\n    lensHttpHandler?: LensHttpHandler;\n}\n\nexport type CameraKitApiHostname = \"camera-kit-api.snapar.com\" | \"api-kit.snapchat.com\";\n\n/**\n * Represents a font to be used by Camera Kit for text rendering.\n */\nexport interface Font {\n    /**\n     * A unique name for the font.\n     */\n    name: string;\n\n    /**\n     * A buffer containing the font data (e.g., the contents of a `.ttf` file).\n     */\n    data: ArrayBuffer;\n}\n\n/**\n * Represents context for an HTTP request made by a Lens.\n *\n * This interface provides detailed information about the request, such as its identifier,\n * method, data payload, headers, and associated Lens object.\n */\nexport interface LensHttpRequest {\n    /**\n     * The URL of the HTTP request.\n     */\n    url: string;\n\n    /**\n     * A unique identifier for the HTTP request.\n     */\n    identifier: string;\n\n    /**\n     * The HTTP method of the request (e.g., GET, POST, PUT, DELETE).\n     */\n    method: string;\n\n    /**\n     * The raw data payload for the HTTP request, represented as an `ArrayBuffer`.\n     */\n    data: ArrayBuffer;\n\n    /**\n     * The headers included in the HTTP request.\n     */\n    headers: Record<string, string>;\n\n    /**\n     * The {@link Lens} that initiated this request.\n     */\n    lens: Lens;\n}\n\n/**\n * A handler function for customizing HTTP requests made by a Lens.\n *\n * This function is called whenever a Lens  makes an HTTP request.\n * It allows you to modify the request or response, integrate custom HTTP libraries,\n * add authentication, or log request details.\n *\n * @param url - The URL for the HTTP request.\n * @param init - The initial configuration for the HTTP request, following the Fetch API's `RequestInit`.\n * @param lensRequest - Additional context about the Lens-specific request.\n * @returns A Promise resolving to the HTTP response (`Response`).\n */\nexport type LensHttpHandler = (url: string, init: RequestInit, lensRequest: LensHttpRequest) => Promise<Response>;\n\n/**\n * Configuration which must be provided when calling {@link bootstrapCameraKit}. These values are used to create various\n * CameraKit components.\n *\n * @category Bootstrapping and Configuration\n */\nexport interface CameraKitBootstrapConfiguration {\n    /**\n     * Long-lived token granting your application access to CameraKit APIs. This is found in the SnapKit Dev Portal,\n     * where it's called the API Token.\n     */\n    apiToken: string;\n\n    /**\n     * Determine where to print CameraKit log messages. By default no logs will be printed.\n     *\n     * CameraKit emits log messages to help diagnose and root cause issues that may occur during the development of a\n     * host application. The printing of these can be controlled via the following\n     * options:\n     *  - `noop`: log messages are ignored.\n     *  - `console`: log messages are printed to console.\n     */\n    logger?: \"noop\" | \"console\";\n\n    /**\n     * Log only if a logged entry level is greater than or equal to this level. Here is the order of levels:\n     * error > warn > log = info > debug. Default value is \"info\".\n     */\n    logLevel?: LogLevelName;\n\n    /**\n     * Some lenses may decide to modify their behavior based on the performance of the current environment. If you are\n     * using such lenses, providing an estimation of lens performance may lead to better user experience (especially on\n     * low-performance devices).\n     *\n     * Running the {@link estimateLensPerformance} function will run benchmarks and estimate an appropriate lens\n     * performance cluster (i.e. a performance rating) based on the current environment.\n     *\n     * Lower cluster = worse expected performance capability.\n     *\n     * @example\n     * ```ts\n     * import { bootstrapCameraKit, estimateLensPerformance } from '@snap/camera-kit`\n     *\n     * const cameraKit = await bootstrapCameraKit({\n     *   apiToken: '...',\n     *   lensPerformance: estimateLensPerformance(),\n     * })\n     * ```\n     */\n    lensPerformance?: EstimatedLensPerformance | Promise<EstimatedLensPerformance>;\n\n    /**\n     * In recommended production deployments, the WebAssembly assets required by CameraKit will be downloaded from an\n     * optimized CDN. But sometimes (e.g. during development or within a CI pipeline), it may be necessary to download\n     * these assets from somewhere else.\n     *\n     * This configuration option allows the application to specify URLs to be used for both the WebAssembly and JS glue\n     * file that are used to run and interact with CameraKit's rendering engine.\n     */\n    lensCoreOverrideUrls?: { wasm: string; js: string };\n\n    /**\n     * In recommended production deployments, the WebAssembly assets required by CameraKit will be downloaded from an\n     * optimized CDN. But sometimes during development or within a CI pipeline, it may be necessary to download these\n     * assets from somewhere else. With a provided `wasmEndpointOverride`, asset URLs will be automatically generated\n     * based on this root endpoint.\n     */\n    wasmEndpointOverride?: string;\n\n    /**\n     * Applications may optionally provide a unique identifier called analyticsId. This ID would enable Camera Kit to\n     * improve data reporting and accuracy and to better support potential needs related to an application's lens and\n     * user analytics.\n     */\n    analyticsId?: string;\n\n    /**\n     * An array of fonts to be used by Camera Kit for text rendering.\n     *\n     * Lenses usually have their own font assets, but emojis are often not embedded.\n     * As a result, you may need to provide additional fonts (e.g., an emoji font) to ensure all glyphs render\n     * correctly.\n     *\n     * @example\n     * fonts: [\n     *   {\n     *     name: 'EmojiFont',\n     *     data: emojiFontArrayBuffer, // Your emoji font data goes here\n     *   },\n     * ]\n     */\n    fonts?: Font[];\n\n    /**\n     * An optional custom HTTP handler for requests made by a Lens.\n     *\n     * This handler allows you to intercept and customize the behavior of HTTP requests,\n     * such as adding authentication headers, logging request details, or replacing the default\n     * HTTP library used by the Lens system.\n     *\n     * If not specified, the Lens system will use a default HTTP implementation.\n     *\n     * @example\n     * Here is an example of how to configure a custom `LensHttpHandler` to add an authentication token:\n     *\n     * ```typescript\n     * const customLensHttpHandler: LensHttpHandler = async (url, init, lensRequest) => {\n     *   // Add an authentication token to the headers\n     *   const sessionToken = await getAuthToken();\n     *   const updatedInit = {\n     *     ...init,\n     *     headers: {\n     *       ...init.headers,\n     *       'Authorization': `Bearer ${sessionToken}`,\n     *     },\n     *   };\n     *\n     *   // Log the request details for debugging\n     *   console.log(`Requesting ${lensRequest.url} from lens: ${lensRequest.lens.name}`);\n     *\n     *   // Use fetch to perform the HTTP request\n     *   return fetch(url, updatedInit);\n     * };\n     *\n     * const cameraKit = bootstrapCameraKit({\n     *   apiToken,\n     *   lensHttpHandler: customLensHttpHandler,\n     * });\n     * ```\n     */\n    lensHttpHandler?: LensHttpHandler;\n}\n\n/**\n * This type represents the result of merging user-supplied config with default config -- as such, it has no nullable\n * fields, making it a more convenient type for other components to use.\n *\n * @internal\n */\nexport type CameraKitConfiguration = CameraKitRuntimeConfiguration & CameraKitBootstrapConfiguration;\n\n/** @internal */\nexport const configurationToken = \"configuration\";\n\n/**\n * Returns true if given browser is iPhone, iPad or iPod.\n */\nfunction isHandledAppleDevice() {\n    // We use the same approach LC uses:\n    // eslint-disable-next-line max-len\n    // https://github.sc-corp.net/Snapchat/LensCore/blob/285ac47cad7fe5268f38d1bab82d51b7b19d6b48/Src/PlatformSpecific/WebAssembly/WebEnvironmentInfo.cpp#L81\n    return (\n        /iPad|iPhone|iPod/.test(navigator.platform) ||\n        (navigator.platform === \"MacIntel\" && navigator.maxTouchPoints > 2)\n    );\n}\n\n/** @internal */\nexport const createCameraKitConfigurationFactory = (configuration: CameraKitBootstrapConfiguration) => {\n    // always leave debug mode warning about overrides in console\n    const overrides = getConfigurationOverrides();\n    if (overrides) {\n        console.warn(\"Configuration overrides applied\", overrides);\n    }\n    return Injectable(configurationToken, (): CameraKitConfiguration => {\n        // We'll ensure that we handle errors on any Promises passed as config values, otherwise we either must\n        // handle them separately wherever they're used, or rejections would go unhandled.\n        const safeConfig: CameraKitBootstrapConfiguration = {\n            ...configuration,\n            lensPerformance:\n                configuration.lensPerformance instanceof Promise\n                    ? // Safety: defaultConfiguration.lensPerformance is defined (it's hardcoded above).\n                      configuration.lensPerformance.catch(() => defaultConfiguration.lensPerformance!)\n                    : configuration.lensPerformance,\n        };\n        return {\n            ...defaultConfiguration,\n            // TODO: Safari 17 has an issue with offscreen canvas which results in stuttering effect on iOS.\n            // Once Safari has that fixed, we should remove this check, see https://jira.sc-corp.net/browse/CAMKIT-5985\n            shouldUseWorker: isHandledAppleDevice() ? false : defaultConfiguration.shouldUseWorker,\n            ...copyDefinedProperties(safeConfig),\n            ...copyDefinedProperties(overrides ?? {}),\n        };\n    });\n};\n"]}
+{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../src/configuration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,EAAE,SAAS,EAAE,UAAU,EAA8B,MAAM,iBAAiB,CAAC;AAapF,MAAM,oBAAoB,GAAmF;IAIzG,eAAe,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,iBAAiB,EAAE,SAAS,EAAE;IAC7E,MAAM,EAAE,UAAU;IAClB,QAAQ,EAAE,MAAM;IAChB,eAAe,EAAE,IAAI;IACrB,WAAW,EAAE,2BAA2B;IACxC,eAAe,EAAE,SAAS;IAC1B,KAAK,EAAE,EAAE;IACT,sBAAsB,EAAE,iBAAiB;CAC5C,CAAC;AAwOF,MAAM,CAAC,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAKlD,SAAS,oBAAoB;IAIzB,OAAO,CACH,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;QAC3C,CAAC,SAAS,CAAC,QAAQ,KAAK,UAAU,IAAI,SAAS,CAAC,cAAc,GAAG,CAAC,CAAC,CACtE,CAAC;AACN,CAAC;AAGD,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,aAA8C,EAAE,EAAE;IAElG,MAAM,SAAS,GAAG,yBAAyB,EAAE,CAAC;IAC9C,IAAI,SAAS,EAAE;QACX,OAAO,CAAC,IAAI,CAAC,iCAAiC,EAAE,SAAS,CAAC,CAAC;KAC9D;IACD,OAAO,UAAU,CAAC,kBAAkB,EAAE,GAA2B,EAAE;;QAG/D,MAAM,UAAU,mCACT,aAAa,KAChB,eAAe,EACX,aAAa,CAAC,eAAe,YAAY,OAAO;gBAC5C,CAAC;oBACC,aAAa,CAAC,eAAe,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,oBAAoB,CAAC,eAAgB,CAAC;gBAClF,CAAC,CAAC,aAAa,CAAC,eAAe,GAC1C,CAAC;QACF,iFACO,oBAAoB,KAGvB,eAAe,EAAE,oBAAoB,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,oBAAoB,CAAC,eAAe,KACnF,qBAAqB,CAAC,UAAU,CAAC,GACjC,qBAAqB,CAAC,SAAS,aAAT,SAAS,cAAT,SAAS,GAAI,EAAE,CAAC,KACzC,MAAM,EAAE,SAAS,CAAC,MAAA,UAAU,CAAC,MAAM,mCAAI,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,MAAM,CAAC,IAC3D;IACN,CAAC,CAAC,CAAC;AACP,CAAC,CAAC","sourcesContent":["import { Injectable } from \"@snap/ts-inject\";\nimport type { EstimatedLensPerformance } from \"./benchmark/estimateLensPerformanceCluster\";\nimport { copyDefinedProperties } from \"./common/copyDefinedProperties\";\nimport { getConfigurationOverrides } from \"./configurationOverrides\";\nimport type { Lens } from \"./lens/Lens\";\nimport { mapLogger, noopLogger, type Logger, type LogLevel } from \"./logger/logger\";\n\n/**\n * From T, pick the set of properties whose values are optional. Create a new type containing only those properties.\n */\ntype PickOptionals<T> = {\n    [K in keyof T as T[K] extends Exclude<T[K], undefined> ? never : K]: T[K];\n};\n\n/**\n * Defaults are provided for runtime configuration and any optional bootstrap configuration properties which require\n * defaults.\n */\nconst defaultConfiguration: CameraKitRuntimeConfiguration & PickOptionals<CameraKitBootstrapConfiguration> = {\n    // If the applications doesn't provide performance data (e.g. via estimateLensPerformance), we'll use 0 to indicate\n    // no performance estimation occurred. This is indicative of typical performance-targeting logic, which often\n    // defaults to the lowest-tier experience in the absence of performance cluster data.\n    lensPerformance: { cluster: 0, benchmarks: [], webglRendererInfo: \"unknown\" },\n    logger: noopLogger,\n    logLevel: \"info\",\n    shouldUseWorker: true,\n    apiHostname: \"camera-kit-api.snapar.com\",\n    userAgentFlavor: \"release\",\n    fonts: [],\n    trustedTypesPolicyName: \"snap-camera-kit\",\n};\n\ninterface CameraKitRuntimeConfiguration {\n    lensPerformance: EstimatedLensPerformance | Promise<EstimatedLensPerformance>;\n    logger: Logger;\n    logLevel: LogLevel;\n    shouldUseWorker: boolean;\n    apiHostname: CameraKitApiHostname;\n    userAgentFlavor: \"release\" | \"debug\";\n    fonts: Font[];\n    lensHttpHandler?: LensHttpHandler;\n    trustedTypesPolicyName: string;\n}\n\nexport type CameraKitApiHostname = \"camera-kit-api.snapar.com\" | \"api-kit.snapchat.com\";\n\n/**\n * Represents a font to be used by Camera Kit for text rendering.\n */\nexport interface Font {\n    /**\n     * A unique name for the font.\n     */\n    name: string;\n\n    /**\n     * A buffer containing the font data (e.g., the contents of a `.ttf` file).\n     */\n    data: ArrayBuffer;\n}\n\n/**\n * Represents context for an HTTP request made by a Lens.\n *\n * This interface provides detailed information about the request, such as its identifier,\n * method, data payload, headers, and associated Lens object.\n */\nexport interface LensHttpRequest {\n    /**\n     * The URL of the HTTP request.\n     */\n    url: string;\n\n    /**\n     * A unique identifier for the HTTP request.\n     */\n    identifier: string;\n\n    /**\n     * The HTTP method of the request (e.g., GET, POST, PUT, DELETE).\n     */\n    method: string;\n\n    /**\n     * The raw data payload for the HTTP request, represented as an `ArrayBuffer`.\n     */\n    data: ArrayBuffer;\n\n    /**\n     * The headers included in the HTTP request.\n     */\n    headers: Record<string, string>;\n\n    /**\n     * The {@link Lens} that initiated this request.\n     */\n    lens: Lens;\n}\n\n/**\n * A handler function for customizing HTTP requests made by a Lens.\n *\n * This function is called whenever a Lens  makes an HTTP request.\n * It allows you to modify the request or response, integrate custom HTTP libraries,\n * add authentication, or log request details.\n *\n * @param url - The URL for the HTTP request.\n * @param init - The initial configuration for the HTTP request, following the Fetch API's `RequestInit`.\n * @param lensRequest - Additional context about the Lens-specific request.\n * @returns A Promise resolving to the HTTP response (`Response`).\n */\nexport type LensHttpHandler = (url: string, init: RequestInit, lensRequest: LensHttpRequest) => Promise<Response>;\n\n/**\n * Configuration which must be provided when calling {@link bootstrapCameraKit}. These values are used to create various\n * CameraKit components.\n *\n * @category Bootstrapping and Configuration\n */\nexport interface CameraKitBootstrapConfiguration {\n    /**\n     * Long-lived token granting your application access to CameraKit APIs. This is found in the SnapKit Dev Portal,\n     * where it's called the API Token.\n     */\n    apiToken: string;\n\n    /**\n     * Determine where to print CameraKit log messages. By default no logs will be printed.\n     *\n     * CameraKit emits log messages to help diagnose and root cause issues that may occur during the development of a\n     * host application. The printing of these can be controlled via the following options:\n     *  - `\"noop\"`: log messages are ignored.\n     *  - `\"console\"`: log messages are printed to console.\n     *  - A custom {@link Logger} instance can be provided to integrate with an existing logging system.\n     */\n    logger?: \"noop\" | \"console\" | Logger;\n\n    /**\n     * Log only if a logged entry level is greater than or equal to this level. Here is the order of levels:\n     * error > warn > log = info > debug. Default value is \"info\".\n     */\n    logLevel?: LogLevel;\n\n    /**\n     * Some lenses may decide to modify their behavior based on the performance of the current environment. If you are\n     * using such lenses, providing an estimation of lens performance may lead to better user experience (especially on\n     * low-performance devices).\n     *\n     * Running the {@link estimateLensPerformance} function will run benchmarks and estimate an appropriate lens\n     * performance cluster (i.e. a performance rating) based on the current environment.\n     *\n     * Lower cluster = worse expected performance capability.\n     *\n     * @example\n     * ```ts\n     * import { bootstrapCameraKit, estimateLensPerformance } from '@snap/camera-kit`\n     *\n     * const cameraKit = await bootstrapCameraKit({\n     *   apiToken: '...',\n     *   lensPerformance: estimateLensPerformance(),\n     * })\n     * ```\n     */\n    lensPerformance?: EstimatedLensPerformance | Promise<EstimatedLensPerformance>;\n\n    /**\n     * In recommended production deployments, the WebAssembly assets required by CameraKit will be downloaded from an\n     * optimized CDN. But sometimes (e.g. during development or within a CI pipeline), it may be necessary to download\n     * these assets from somewhere else.\n     *\n     * This configuration option allows the application to specify URLs to be used for both the WebAssembly and JS glue\n     * file that are used to run and interact with CameraKit's rendering engine.\n     */\n    lensCoreOverrideUrls?: { wasm: string; js: string };\n\n    /**\n     * In recommended production deployments, the WebAssembly assets required by CameraKit will be downloaded from an\n     * optimized CDN. But sometimes during development or within a CI pipeline, it may be necessary to download these\n     * assets from somewhere else. With a provided `wasmEndpointOverride`, asset URLs will be automatically generated\n     * based on this root endpoint.\n     */\n    wasmEndpointOverride?: string;\n\n    /**\n     * Applications may optionally provide a unique identifier called analyticsId. This ID would enable Camera Kit to\n     * improve data reporting and accuracy and to better support potential needs related to an application's lens and\n     * user analytics.\n     */\n    analyticsId?: string;\n\n    /**\n     * An array of fonts to be used by Camera Kit for text rendering.\n     *\n     * Lenses usually have their own font assets, but emojis are often not embedded.\n     * As a result, you may need to provide additional fonts (e.g., an emoji font) to ensure all glyphs render\n     * correctly.\n     *\n     * @example\n     * fonts: [\n     *   {\n     *     name: 'EmojiFont',\n     *     data: emojiFontArrayBuffer, // Your emoji font data goes here\n     *   },\n     * ]\n     */\n    fonts?: Font[];\n\n    /**\n     * An optional custom HTTP handler for requests made by a Lens.\n     *\n     * This handler allows you to intercept and customize the behavior of HTTP requests,\n     * such as adding authentication headers, logging request details, or replacing the default\n     * HTTP library used by the Lens system.\n     *\n     * If not specified, the Lens system will use a default HTTP implementation.\n     *\n     * @example\n     * Here is an example of how to configure a custom `LensHttpHandler` to add an authentication token:\n     *\n     * ```typescript\n     * const customLensHttpHandler: LensHttpHandler = async (url, init, lensRequest) => {\n     *   // Add an authentication token to the headers\n     *   const sessionToken = await getAuthToken();\n     *   const updatedInit = {\n     *     ...init,\n     *     headers: {\n     *       ...init.headers,\n     *       'Authorization': `Bearer ${sessionToken}`,\n     *     },\n     *   };\n     *\n     *   // Log the request details for debugging\n     *   console.log(`Requesting ${lensRequest.url} from lens: ${lensRequest.lens.name}`);\n     *\n     *   // Use fetch to perform the HTTP request\n     *   return fetch(url, updatedInit);\n     * };\n     *\n     * const cameraKit = bootstrapCameraKit({\n     *   apiToken,\n     *   lensHttpHandler: customLensHttpHandler,\n     * });\n     * ```\n     */\n    lensHttpHandler?: LensHttpHandler;\n\n    /**\n     * The name of the Trusted Types policy to use when loading scripts.\n     * Defaults to \"snap-camera-kit\".\n     */\n    trustedTypesPolicyName?: string;\n}\n\n/**\n * This type represents the result of merging user-supplied config with default config -- as such, it has no nullable\n * fields, making it a more convenient type for other components to use.\n *\n * @internal\n */\nexport type CameraKitConfiguration = CameraKitRuntimeConfiguration & CameraKitBootstrapConfiguration;\n\n/** @internal */\nexport const configurationToken = \"configuration\";\n\n/**\n * Returns true if given browser is iPhone, iPad or iPod.\n */\nfunction isHandledAppleDevice() {\n    // We use the same approach LC uses:\n    // eslint-disable-next-line max-len\n    // https://github.sc-corp.net/Snapchat/LensCore/blob/285ac47cad7fe5268f38d1bab82d51b7b19d6b48/Src/PlatformSpecific/WebAssembly/WebEnvironmentInfo.cpp#L81\n    return (\n        /iPad|iPhone|iPod/.test(navigator.platform) ||\n        (navigator.platform === \"MacIntel\" && navigator.maxTouchPoints > 2)\n    );\n}\n\n/** @internal */\nexport const createCameraKitConfigurationFactory = (configuration: CameraKitBootstrapConfiguration) => {\n    // always leave debug mode warning about overrides in console\n    const overrides = getConfigurationOverrides();\n    if (overrides) {\n        console.warn(\"Configuration overrides applied\", overrides);\n    }\n    return Injectable(configurationToken, (): CameraKitConfiguration => {\n        // We'll ensure that we handle errors on any Promises passed as config values, otherwise we either must\n        // handle them separately wherever they're used, or rejections would go unhandled.\n        const safeConfig: CameraKitBootstrapConfiguration = {\n            ...configuration,\n            lensPerformance:\n                configuration.lensPerformance instanceof Promise\n                    ? // Safety: defaultConfiguration.lensPerformance is defined (it's hardcoded above).\n                      configuration.lensPerformance.catch(() => defaultConfiguration.lensPerformance!)\n                    : configuration.lensPerformance,\n        };\n        return {\n            ...defaultConfiguration,\n            // TODO: Safari 17 has an issue with offscreen canvas which results in stuttering effect on iOS.\n            // Once Safari has that fixed, we should remove this check, see https://jira.sc-corp.net/browse/CAMKIT-5985\n            shouldUseWorker: isHandledAppleDevice() ? false : defaultConfiguration.shouldUseWorker,\n            ...copyDefinedProperties(safeConfig),\n            ...copyDefinedProperties(overrides ?? {}),\n            logger: mapLogger(safeConfig.logger ?? overrides?.logger),\n        };\n    });\n};\n"]}

package/dist/environment.js

@@ -1,2 +1,2 @@
-export default { PACKAGE_VERSION: "1.10.0" };
+export default { PACKAGE_VERSION: "1.12.0" };
 //# sourceMappingURL=environment.js.map

package/dist/environment.js.map

@@ -1 +1 @@
-{"version":3,"file":"environment.js","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"AAAA,eAAe,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC","sourcesContent":["export default { PACKAGE_VERSION: \"1.10.0\" };\n"]}
+{"version":3,"file":"environment.js","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"AAAA,eAAe,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC","sourcesContent":["export default { PACKAGE_VERSION: \"1.12.0\" };\n"]}