@snap/camera-kit 0.7.0

package/lib/common/localization.d.ts

@@ -0,0 +1,43 @@
+/**
+ * This implementation is limited by how TypeScript currently implements tag function for template literals.
+ *
+ * The way tag functions are typed by the TypeScript compiler limits their usefulness, for two reasons:
+ *
+ * 1. Specific literal types are not inferred from interpolation expressions -- the following does not work:
+ * ```ts
+ * function tag<K extends readonly string[]>(strings: readonly string[], ...keys: K): string { ... }
+ * tag`This is a ${"test"} template.` // the K type parameter is not correctly inferred as `readonly ['test']`
+ * ```
+ * 2. The return type of a function used as a tag function will always be `string` -- the following does not work:
+ * ```ts
+ * function tag<K extends readonly string[]>(
+ *   strings: readonly string[],
+ *   ...keys: K
+ * ): (values: {[k in K[number]]: string}) => string { ... }
+ *
+ * const template = tag`This is a ${"test"} template` // TS infers the type of `template` as `string` -- clearly wrong.
+ * ```
+ *
+ * An attempt is made here to work around those limitations and still provide a reasonably amount of type safety without
+ * adding too much verbosity.
+ *
+ * See https://github.com/microsoft/TypeScript/pull/49552
+ */
+/**
+ * We use the en_US string object to define all localizable stringIds and their types (either a TemplateFunction or a
+ * plain string).
+ */
+declare type LocalizableStrings = typeof en_US;
+declare type TemplateFunction<K extends readonly string[]> = (values: {
+    [key in K[number]]: string;
+}) => string;
+/**
+ * Strings for each language are defined blow.
+ */
+declare const en_US: {
+    legalPromptMessage: TemplateFunction<readonly ["privacyPolicyUrl", "termsOfServiceUrl", "learnMoreUrl"]>;
+    legalPromptAccept: string;
+    legalPromptReject: string;
+};
+export declare function localizedString<ID extends keyof LocalizableStrings>(stringId: ID): LocalizableStrings[ID];
+export {};

package/lib/common/localization.js

@@ -0,0 +1,43 @@
+var _a;
+import { cameraKitUserAgent } from "./cameraKitUserAgent";
+function makeTemplate(keys) {
+    return (template) => (values) => {
+        const tag = (readonlyStrings) => {
+            const strings = readonlyStrings.slice();
+            return [strings.shift()]
+                .concat(keys.map((key) => { var _a; return `${(_a = values[key]) !== null && _a !== void 0 ? _a : ""}${strings.shift()}`; }))
+                .concat(strings)
+                .join("");
+        };
+        return template(tag);
+    };
+}
+/**
+ * Any strings which are templated (i.e. require runtime values) are defined below.
+ */
+const legalPromptMessage = makeTemplate(["privacyPolicyUrl", "termsOfServiceUrl", "learnMoreUrl"]);
+/**
+ * Strings for each language are defined blow.
+ */
+// en_US is used both to:
+//  A) define the set of strings which can be localized and
+//  B) provide a default set of strings in case a specific localization cannot be found.
+const en_US = {
+    legalPromptMessage: legalPromptMessage((tag) => tag `By using Lenses, you acknowledge reading Snap's <a href="${0}" target="_blank">
+            Privacy Policy</a> and agree to Snap's <a href="${0}" target="_blank">Terms of Service</a>.
+            Some Lenses use information about your face, hands, and voice to work. <a href="${0}"
+            target="_blank">Learn More</a>, and if you want to agree and continue, click or tap below.`),
+    legalPromptAccept: "I Agree",
+    legalPromptReject: "Dismiss",
+};
+/**
+ * --- end of string definitions ---
+ */
+const allStrings = {
+    en_US,
+};
+const localizedStrings = (_a = allStrings[cameraKitUserAgent.locale]) !== null && _a !== void 0 ? _a : en_US;
+export function localizedString(stringId) {
+    return localizedStrings[stringId];
+}
+//# sourceMappingURL=localization.js.map

package/lib/common/localization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"localization.js","sourceRoot":"","sources":["../../src/common/localization.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAoC1D,SAAS,YAAY,CACjB,IAAO;IAEP,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,MAAsC,EAAE,EAAE;QAC5D,MAAM,GAAG,GAAG,CAAC,eAAkC,EAAE,EAAE;YAC/C,MAAM,OAAO,GAAG,eAAe,CAAC,KAAK,EAAE,CAAC;YACxC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;iBACnB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,WAAC,OAAA,GAAG,MAAA,MAAM,CAAC,GAAG,CAAC,mCAAI,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,EAAE,CAAA,EAAA,CAAC,CAAC;iBACnE,MAAM,CAAC,OAAO,CAAC;iBACf,IAAI,CAAC,EAAE,CAAC,CAAC;QAClB,CAAC,CAAC;QACF,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC,CAAC;AACN,CAAC;AAED;;GAEG;AACH,MAAM,kBAAkB,GAAG,YAAY,CAAC,CAAC,kBAAkB,EAAE,mBAAmB,EAAE,cAAc,CAAU,CAAC,CAAC;AAE5G;;GAEG;AAEH,yBAAyB;AACzB,2DAA2D;AAC3D,wFAAwF;AACxF,MAAM,KAAK,GAAG;IACV,kBAAkB,EAAE,kBAAkB,CAClC,CAAC,GAAG,EAAE,EAAE,CACJ,GAAG,CAAA,4DAA4D,CAAC;8DACd,CAAC;8FAC+B,CAAC;uGACQ,CAClG;IACD,iBAAiB,EAAE,SAAS;IAC5B,iBAAiB,EAAE,SAAS;CAC/B,CAAC;AAEF;;GAEG;AAEH,MAAM,UAAU,GAA0C;IACtD,KAAK;CACR,CAAC;AAEF,MAAM,gBAAgB,GAAG,MAAA,UAAU,CAAC,kBAAkB,CAAC,MAAM,CAAC,mCAAI,KAAK,CAAC;AAExE,MAAM,UAAU,eAAe,CAAsC,QAAY;IAC7E,OAAO,gBAAgB,CAAC,QAAQ,CAAC,CAAC;AACtC,CAAC","sourcesContent":["import { cameraKitUserAgent } from \"./cameraKitUserAgent\";\n\n/**\n * This implementation is limited by how TypeScript currently implements tag function for template literals.\n *\n * The way tag functions are typed by the TypeScript compiler limits their usefulness, for two reasons:\n *\n * 1. Specific literal types are not inferred from interpolation expressions -- the following does not work:\n * ```ts\n * function tag<K extends readonly string[]>(strings: readonly string[], ...keys: K): string { ... }\n * tag`This is a ${\"test\"} template.` // the K type parameter is not correctly inferred as `readonly ['test']`\n * ```\n * 2. The return type of a function used as a tag function will always be `string` -- the following does not work:\n * ```ts\n * function tag<K extends readonly string[]>(\n *   strings: readonly string[],\n *   ...keys: K\n * ): (values: {[k in K[number]]: string}) => string { ... }\n *\n * const template = tag`This is a ${\"test\"} template` // TS infers the type of `template` as `string` -- clearly wrong.\n * ```\n *\n * An attempt is made here to work around those limitations and still provide a reasonably amount of type safety without\n * adding too much verbosity.\n *\n * See https://github.com/microsoft/TypeScript/pull/49552\n */\n\n/**\n * We use the en_US string object to define all localizable stringIds and their types (either a TemplateFunction or a\n * plain string).\n */\ntype LocalizableStrings = typeof en_US;\n\ntype TemplateFunction<K extends readonly string[]> = (values: { [key in K[number]]: string }) => string;\n\nfunction makeTemplate<K extends readonly string[]>(\n    keys: K\n): (template: (tag: (strings: readonly string[], ...keys: 0[]) => string) => string) => TemplateFunction<K> {\n    return (template) => (values: { [key in K[number]]: string }) => {\n        const tag = (readonlyStrings: readonly string[]) => {\n            const strings = readonlyStrings.slice();\n            return [strings.shift()]\n                .concat(keys.map((key) => `${values[key] ?? \"\"}${strings.shift()}`))\n                .concat(strings)\n                .join(\"\");\n        };\n        return template(tag);\n    };\n}\n\n/**\n * Any strings which are templated (i.e. require runtime values) are defined below.\n */\nconst legalPromptMessage = makeTemplate([\"privacyPolicyUrl\", \"termsOfServiceUrl\", \"learnMoreUrl\"] as const);\n\n/**\n * Strings for each language are defined blow.\n */\n\n// en_US is used both to:\n//  A) define the set of strings which can be localized and\n//  B) provide a default set of strings in case a specific localization cannot be found.\nconst en_US = {\n    legalPromptMessage: legalPromptMessage(\n        (tag) =>\n            tag`By using Lenses, you acknowledge reading Snap's <a href=\"${0}\" target=\"_blank\">\n            Privacy Policy</a> and agree to Snap's <a href=\"${0}\" target=\"_blank\">Terms of Service</a>.\n            Some Lenses use information about your face, hands, and voice to work. <a href=\"${0}\"\n            target=\"_blank\">Learn More</a>, and if you want to agree and continue, click or tap below.`\n    ),\n    legalPromptAccept: \"I Agree\",\n    legalPromptReject: \"Dismiss\",\n};\n\n/**\n * --- end of string definitions ---\n */\n\nconst allStrings: { [key: string]: LocalizableStrings } = {\n    en_US,\n};\n\nconst localizedStrings = allStrings[cameraKitUserAgent.locale] ?? en_US;\n\nexport function localizedString<ID extends keyof LocalizableStrings>(stringId: ID): LocalizableStrings[ID] {\n    return localizedStrings[stringId];\n}\n"]}

package/lib/common/memoize.d.ts

@@ -0,0 +1,8 @@
+declare type AnyFunction<A extends any[] = any[], B = any> = (...args: A) => B;
+export declare type Memoized<Fn extends AnyFunction> = {
+    (...args: Parameters<Fn>): ReturnType<Fn>;
+    delegate: Fn;
+};
+export declare function isMemoized(fn: unknown): fn is Memoized<AnyFunction>;
+export declare function memoize<Fn extends AnyFunction>(delegate: Fn): Memoized<Fn>;
+export {};

package/lib/common/memoize.js

@@ -0,0 +1,15 @@
+export function isMemoized(fn) {
+    return typeof fn === "function" && typeof fn.delegate === "function";
+}
+export function memoize(delegate) {
+    let memo;
+    const memoized = (...args) => {
+        if (typeof memo !== "undefined")
+            return memo;
+        memo = delegate(...args);
+        return memo;
+    };
+    memoized.delegate = delegate;
+    return memoized;
+}
+//# sourceMappingURL=memoize.js.map

package/lib/common/memoize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.js","sourceRoot":"","sources":["../../src/common/memoize.ts"],"names":[],"mappings":"AAOA,MAAM,UAAU,UAAU,CAAC,EAAW;IAClC,OAAO,OAAO,EAAE,KAAK,UAAU,IAAI,OAAQ,EAAU,CAAC,QAAQ,KAAK,UAAU,CAAC;AAClF,CAAC;AAED,MAAM,UAAU,OAAO,CAAyB,QAAY;IACxD,IAAI,IAAS,CAAC;IACd,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAW,EAAE,EAAE;QAChC,IAAI,OAAO,IAAI,KAAK,WAAW;YAAE,OAAO,IAAI,CAAC;QAC7C,IAAI,GAAG,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC;IAChB,CAAC,CAAC;IACF,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC7B,OAAO,QAAQ,CAAC;AACpB,CAAC","sourcesContent":["type AnyFunction<A extends any[] = any[], B = any> = (...args: A) => B;\n\nexport type Memoized<Fn extends AnyFunction> = {\n    (...args: Parameters<Fn>): ReturnType<Fn>;\n    delegate: Fn;\n};\n\nexport function isMemoized(fn: unknown): fn is Memoized<AnyFunction> {\n    return typeof fn === \"function\" && typeof (fn as any).delegate === \"function\";\n}\n\nexport function memoize<Fn extends AnyFunction>(delegate: Fn): Memoized<Fn> {\n    let memo: any;\n    const memoized = (...args: any[]) => {\n        if (typeof memo !== \"undefined\") return memo;\n        memo = delegate(...args);\n        return memo;\n    };\n    memoized.delegate = delegate;\n    return memoized;\n}\n"]}

package/lib/common/pageVisibility.d.ts

@@ -0,0 +1,20 @@
+export declare function isDuringVisibilityTransition(test: DocumentVisibilityState): boolean;
+/**
+ * Run a function when the page is hidden. If this occurs due to tab / browser closure, only synchronous functions will
+ * run to completion.
+ *
+ * If the given handler throws an error, it will be silently swallowed.
+ *
+ * @param handler
+ * @returns A function which, when called, removes the function from the set of visibility change handlers.
+ */
+export declare function onPageHidden(handler: () => void): () => void;
+/**
+ * Run a function when the page is made visible.
+ *
+ * If the given handler throws an error, it will be silently swallowed.
+ *
+ * @param handler
+ * @returns A function which, when called, removes the function from the set of visibility change handlers.
+ */
+export declare function onPageVisible(handler: () => void): () => void;

package/lib/common/pageVisibility.js

@@ -0,0 +1,62 @@
+const onHiddenHandlers = new Set();
+const onVisibleHandlers = new Set();
+let previousVisibilityState = document.visibilityState;
+let visibilityTransition = false;
+let initialized = false;
+function maybeInitializeVisibilityListeners() {
+    if (initialized)
+        return;
+    initialized = true;
+    document.addEventListener("visibilitychange", () => {
+        const handlers = previousVisibilityState === "visible" && document.visibilityState === "hidden"
+            ? onHiddenHandlers
+            : previousVisibilityState === "hidden" && document.visibilityState === "visible"
+                ? onVisibleHandlers
+                : new Set();
+        visibilityTransition = document.visibilityState;
+        for (const handler of handlers) {
+            try {
+                handler();
+            }
+            catch (error) {
+                // We'll do the same thing here that we would do if the handler was added directly as an event
+                // listener and dispatch an error event if we can.
+                if (typeof window === "object")
+                    window.dispatchEvent(new CustomEvent("error", { detail: error }));
+            }
+        }
+        previousVisibilityState = visibilityTransition;
+        visibilityTransition = false;
+    });
+}
+export function isDuringVisibilityTransition(test) {
+    return test === visibilityTransition;
+}
+/**
+ * Run a function when the page is hidden. If this occurs due to tab / browser closure, only synchronous functions will
+ * run to completion.
+ *
+ * If the given handler throws an error, it will be silently swallowed.
+ *
+ * @param handler
+ * @returns A function which, when called, removes the function from the set of visibility change handlers.
+ */
+export function onPageHidden(handler) {
+    maybeInitializeVisibilityListeners();
+    onHiddenHandlers.add(handler);
+    return () => onHiddenHandlers.delete(handler);
+}
+/**
+ * Run a function when the page is made visible.
+ *
+ * If the given handler throws an error, it will be silently swallowed.
+ *
+ * @param handler
+ * @returns A function which, when called, removes the function from the set of visibility change handlers.
+ */
+export function onPageVisible(handler) {
+    maybeInitializeVisibilityListeners();
+    onVisibleHandlers.add(handler);
+    return () => onVisibleHandlers.delete(handler);
+}
+//# sourceMappingURL=pageVisibility.js.map

package/lib/common/pageVisibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pageVisibility.js","sourceRoot":"","sources":["../../src/common/pageVisibility.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAc,CAAC;AAC/C,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAc,CAAC;AAEhD,IAAI,uBAAuB,GAAG,QAAQ,CAAC,eAAe,CAAC;AACvD,IAAI,oBAAoB,GAAoC,KAAK,CAAC;AAElE,IAAI,WAAW,GAAG,KAAK,CAAC;AACxB,SAAS,kCAAkC;IACvC,IAAI,WAAW;QAAE,OAAO;IACxB,WAAW,GAAG,IAAI,CAAC;IAEnB,QAAQ,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,GAAG,EAAE;QAC/C,MAAM,QAAQ,GACV,uBAAuB,KAAK,SAAS,IAAI,QAAQ,CAAC,eAAe,KAAK,QAAQ;YAC1E,CAAC,CAAC,gBAAgB;YAClB,CAAC,CAAC,uBAAuB,KAAK,QAAQ,IAAI,QAAQ,CAAC,eAAe,KAAK,SAAS;gBAChF,CAAC,CAAC,iBAAiB;gBACnB,CAAC,CAAC,IAAI,GAAG,EAAc,CAAC;QAEhC,oBAAoB,GAAG,QAAQ,CAAC,eAAe,CAAC;QAEhD,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;YAC5B,IAAI;gBACA,OAAO,EAAE,CAAC;aACb;YAAC,OAAO,KAAK,EAAE;gBACZ,8FAA8F;gBAC9F,kDAAkD;gBAClD,IAAI,OAAO,MAAM,KAAK,QAAQ;oBAAE,MAAM,CAAC,aAAa,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;aACrG;SACJ;QAED,uBAAuB,GAAG,oBAAoB,CAAC;QAC/C,oBAAoB,GAAG,KAAK,CAAC;IACjC,CAAC,CAAC,CAAC;AACP,CAAC;AAED,MAAM,UAAU,4BAA4B,CAAC,IAA6B;IACtE,OAAO,IAAI,KAAK,oBAAoB,CAAC;AACzC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,OAAmB;IAC5C,kCAAkC,EAAE,CAAC;IACrC,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC9B,OAAO,GAAG,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,OAAmB;IAC7C,kCAAkC,EAAE,CAAC;IACrC,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC/B,OAAO,GAAG,EAAE,CAAC,iBAAiB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AACnD,CAAC","sourcesContent":["const onHiddenHandlers = new Set<() => void>();\nconst onVisibleHandlers = new Set<() => void>();\n\nlet previousVisibilityState = document.visibilityState;\nlet visibilityTransition: false | DocumentVisibilityState = false;\n\nlet initialized = false;\nfunction maybeInitializeVisibilityListeners(): void {\n    if (initialized) return;\n    initialized = true;\n\n    document.addEventListener(\"visibilitychange\", () => {\n        const handlers =\n            previousVisibilityState === \"visible\" && document.visibilityState === \"hidden\"\n                ? onHiddenHandlers\n                : previousVisibilityState === \"hidden\" && document.visibilityState === \"visible\"\n                ? onVisibleHandlers\n                : new Set<() => void>();\n\n        visibilityTransition = document.visibilityState;\n\n        for (const handler of handlers) {\n            try {\n                handler();\n            } catch (error) {\n                // We'll do the same thing here that we would do if the handler was added directly as an event\n                // listener and dispatch an error event if we can.\n                if (typeof window === \"object\") window.dispatchEvent(new CustomEvent(\"error\", { detail: error }));\n            }\n        }\n\n        previousVisibilityState = visibilityTransition;\n        visibilityTransition = false;\n    });\n}\n\nexport function isDuringVisibilityTransition(test: DocumentVisibilityState): boolean {\n    return test === visibilityTransition;\n}\n\n/**\n * Run a function when the page is hidden. If this occurs due to tab / browser closure, only synchronous functions will\n * run to completion.\n *\n * If the given handler throws an error, it will be silently swallowed.\n *\n * @param handler\n * @returns A function which, when called, removes the function from the set of visibility change handlers.\n */\nexport function onPageHidden(handler: () => void): () => void {\n    maybeInitializeVisibilityListeners();\n    onHiddenHandlers.add(handler);\n    return () => onHiddenHandlers.delete(handler);\n}\n\n/**\n * Run a function when the page is made visible.\n *\n * If the given handler throws an error, it will be silently swallowed.\n *\n * @param handler\n * @returns A function which, when called, removes the function from the set of visibility change handlers.\n */\nexport function onPageVisible(handler: () => void): () => void {\n    maybeInitializeVisibilityListeners();\n    onVisibleHandlers.add(handler);\n    return () => onVisibleHandlers.delete(handler);\n}\n"]}

package/lib/common/time.d.ts

@@ -0,0 +1 @@
+export declare const getTimeMs: () => number;

package/lib/common/time.js

@@ -0,0 +1,2 @@
+export const getTimeMs = () => performance.now();
+//# sourceMappingURL=time.js.map

package/lib/common/time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","sourceRoot":"","sources":["../../src/common/time.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,EAAE,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC","sourcesContent":["export const getTimeMs = () => performance.now();\n"]}

package/lib/common/typeguards.d.ts

@@ -0,0 +1,53 @@
+declare type UnknownRecord<T = unknown> = Record<string | number | symbol, T>;
+export declare type Guard<T, U = unknown> = (value: U | T) => value is T;
+export declare function isString(value: unknown): value is string;
+/**
+ * Ensures given value is a safe string.
+ *
+ * Safe strings allow to prevent CRLF attacks. We use encoding approach inspired by:
+ * https://community.veracode.com/s/question/0D53n00007hJJV5CAO/is-cwe-id-117-intended-for-consolelog
+ */
+export declare function isSafeString(value: unknown): value is string;
+export declare function isNumber(value: unknown): value is number;
+export declare function isNotNull<T>(value: T): value is Exclude<T, null>;
+export declare function isArrayOfType<T>(elementTypeGuard: Guard<T>, value: unknown): value is T[];
+export declare function isStringArray<T>(value: unknown): value is T[];
+export declare function isSafeStringArray<T>(value: unknown): value is T[];
+/**
+ * Guards given value is instance of ArrayBuffer.
+ */
+export declare function isArrayBuffer(value: unknown): value is ArrayBuffer;
+/**
+ * Guards given value is a typed array.
+ */
+export declare function isTypedArray<T>(value: unknown): value is T;
+/**
+ * Guards given object is not undefined.
+ */
+export declare function isUndefined<T>(value: unknown): value is T;
+/**
+ * Narrow an unknown type to a Record (i.e. a non-null JS object). This holds true for class instances, not just
+ * plain objects.
+ */
+export declare function isRecord(value: unknown): value is UnknownRecord;
+/**
+ * Check if the value is an arbitrary function
+ */
+export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+/**
+ * Apply a given type predicate asserting values are of type T to each value in a Record.
+ *
+ * @param predicate Any unary type predicate
+ * @returns A type predicate which takes an UnknownRecord and tests that all its values are of type T
+ */
+export declare function predicateRecordValues<T>(predicate: (value: unknown) => value is T): (value: UnknownRecord) => value is UnknownRecord<T>;
+/**
+ * Checks whether given value is undefined or a safe URL string.
+ *
+ * The function checks whether given string is a valid URL with https: protocol.
+ *
+ * @param urlString URL string to check.
+ * @returns True if URL is valid.
+ */
+export declare function isEmptyOrSafeUrl(urlString: string | undefined): boolean;
+export {};

package/lib/common/typeguards.js

@@ -0,0 +1,92 @@
+export function isString(value) {
+    return typeof value === "string";
+}
+/**
+ * Ensures given value is a safe string.
+ *
+ * Safe strings allow to prevent CRLF attacks. We use encoding approach inspired by:
+ * https://community.veracode.com/s/question/0D53n00007hJJV5CAO/is-cwe-id-117-intended-for-consolelog
+ */
+export function isSafeString(value) {
+    return isString(value) && encodeURIComponent(value) === value;
+}
+export function isNumber(value) {
+    return typeof value === "number";
+}
+export function isNotNull(value) {
+    return value !== null;
+}
+export function isArrayOfType(elementTypeGuard, value) {
+    return Array.isArray(value) && value.every((id) => elementTypeGuard(id));
+}
+export function isStringArray(value) {
+    return isArrayOfType(isString, value);
+}
+export function isSafeStringArray(value) {
+    return isArrayOfType(isSafeString, value);
+}
+/**
+ * Guards given value is instance of ArrayBuffer.
+ */
+export function isArrayBuffer(value) {
+    return value instanceof ArrayBuffer;
+}
+/**
+ * Guards given value is a typed array.
+ */
+export function isTypedArray(value) {
+    return value instanceof Object.getPrototypeOf(Uint8Array);
+}
+/**
+ * Guards given object is not undefined.
+ */
+export function isUndefined(value) {
+    return typeof value === "undefined";
+}
+/**
+ * Narrow an unknown type to a Record (i.e. a non-null JS object). This holds true for class instances, not just
+ * plain objects.
+ */
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Check if the value is an arbitrary function
+ */
+export function isFunction(value) {
+    return typeof value === "function";
+}
+/**
+ * Apply a given type predicate asserting values are of type T to each value in a Record.
+ *
+ * @param predicate Any unary type predicate
+ * @returns A type predicate which takes an UnknownRecord and tests that all its values are of type T
+ */
+export function predicateRecordValues(predicate) {
+    return (value) => {
+        for (const v of Object.values(value))
+            if (!predicate(v))
+                return false;
+        return true;
+    };
+}
+/**
+ * Checks whether given value is undefined or a safe URL string.
+ *
+ * The function checks whether given string is a valid URL with https: protocol.
+ *
+ * @param urlString URL string to check.
+ * @returns True if URL is valid.
+ */
+export function isEmptyOrSafeUrl(urlString) {
+    if (!urlString)
+        return true;
+    try {
+        const url = new URL(urlString);
+        return url.protocol === "https:" || url.protocol === "http:";
+    }
+    catch (_a) {
+        return false;
+    }
+}
+//# sourceMappingURL=typeguards.js.map

package/lib/common/typeguards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeguards.js","sourceRoot":"","sources":["../../src/common/typeguards.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,QAAQ,CAAC,KAAc;IACnC,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC;AACrC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACvC,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;AAClE,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,KAAc;IACnC,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC;AACrC,CAAC;AACD,MAAM,UAAU,SAAS,CAAI,KAAQ;IACjC,OAAO,KAAK,KAAK,IAAI,CAAC;AAC1B,CAAC;AACD,MAAM,UAAU,aAAa,CAAI,gBAA0B,EAAE,KAAc;IACvE,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,CAAC;AAC7E,CAAC;AACD,MAAM,UAAU,aAAa,CAAI,KAAc;IAC3C,OAAO,aAAa,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAI,KAAc;IAC/C,OAAO,aAAa,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;AAC9C,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IACxC,OAAO,KAAK,YAAY,WAAW,CAAC;AACxC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY,CAAI,KAAc;IAC1C,OAAO,KAAK,YAAY,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;AAC9D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAI,KAAc;IACzC,OAAO,OAAO,KAAK,KAAK,WAAW,CAAC;AACxC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAc;IACnC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAChF,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,KAAc;IACrC,OAAO,OAAO,KAAK,KAAK,UAAU,CAAC;AACvC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAI,SAAyC;IAC9E,OAAO,CAAC,KAAoB,EAA6B,EAAE;QACvD,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;YAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;gBAAE,OAAO,KAAK,CAAC;QACtE,OAAO,IAAI,CAAC;IAChB,CAAC,CAAC;AACN,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,SAA6B;IAC1D,IAAI,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAC5B,IAAI;QACA,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;QAC/B,OAAO,GAAG,CAAC,QAAQ,KAAK,QAAQ,IAAI,GAAG,CAAC,QAAQ,KAAK,OAAO,CAAC;KAChE;IAAC,WAAM;QACJ,OAAO,KAAK,CAAC;KAChB;AACL,CAAC","sourcesContent":["type UnknownRecord<T = unknown> = Record<string | number | symbol, T>;\nexport type Guard<T, U = unknown> = (value: U | T) => value is T;\n\nexport function isString(value: unknown): value is string {\n    return typeof value === \"string\";\n}\n\n/**\n * Ensures given value is a safe string.\n *\n * Safe strings allow to prevent CRLF attacks. We use encoding approach inspired by:\n * https://community.veracode.com/s/question/0D53n00007hJJV5CAO/is-cwe-id-117-intended-for-consolelog\n */\nexport function isSafeString(value: unknown): value is string {\n    return isString(value) && encodeURIComponent(value) === value;\n}\n\nexport function isNumber(value: unknown): value is number {\n    return typeof value === \"number\";\n}\nexport function isNotNull<T>(value: T): value is Exclude<T, null> {\n    return value !== null;\n}\nexport function isArrayOfType<T>(elementTypeGuard: Guard<T>, value: unknown): value is T[] {\n    return Array.isArray(value) && value.every((id) => elementTypeGuard(id));\n}\nexport function isStringArray<T>(value: unknown): value is T[] {\n    return isArrayOfType(isString, value);\n}\n\nexport function isSafeStringArray<T>(value: unknown): value is T[] {\n    return isArrayOfType(isSafeString, value);\n}\n\n/**\n * Guards given value is instance of ArrayBuffer.\n */\nexport function isArrayBuffer(value: unknown): value is ArrayBuffer {\n    return value instanceof ArrayBuffer;\n}\n\n/**\n * Guards given value is a typed array.\n */\nexport function isTypedArray<T>(value: unknown): value is T {\n    return value instanceof Object.getPrototypeOf(Uint8Array);\n}\n\n/**\n * Guards given object is not undefined.\n */\nexport function isUndefined<T>(value: unknown): value is T {\n    return typeof value === \"undefined\";\n}\n\n/**\n * Narrow an unknown type to a Record (i.e. a non-null JS object). This holds true for class instances, not just\n * plain objects.\n */\nexport function isRecord(value: unknown): value is UnknownRecord {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/**\n * Check if the value is an arbitrary function\n */\nexport function isFunction(value: unknown): value is (...args: unknown[]) => unknown {\n    return typeof value === \"function\";\n}\n\n/**\n * Apply a given type predicate asserting values are of type T to each value in a Record.\n *\n * @param predicate Any unary type predicate\n * @returns A type predicate which takes an UnknownRecord and tests that all its values are of type T\n */\nexport function predicateRecordValues<T>(predicate: (value: unknown) => value is T) {\n    return (value: UnknownRecord): value is UnknownRecord<T> => {\n        for (const v of Object.values(value)) if (!predicate(v)) return false;\n        return true;\n    };\n}\n\n/**\n * Checks whether given value is undefined or a safe URL string.\n *\n * The function checks whether given string is a valid URL with https: protocol.\n *\n * @param urlString URL string to check.\n * @returns True if URL is valid.\n */\nexport function isEmptyOrSafeUrl(urlString: string | undefined): boolean {\n    if (!urlString) return true;\n    try {\n        const url = new URL(urlString);\n        return url.protocol === \"https:\" || url.protocol === \"http:\";\n    } catch {\n        return false;\n    }\n}\n"]}

package/lib/common/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * For instances where we'd like to define a Tuple to be of certain type and length.
+ * Example: TupleOf<number, 3> // [number, number, number]
+ *
+ * For more example and use cases regarding Recursive conditional types
+ * see: https://github.com/microsoft/TypeScript/pull/40002
+ */
+declare type _TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : _TupleOf<T, N, [T, ...R]>;
+export declare type TupleOf<T, N extends number> = N extends N ? (number extends N ? T[] : _TupleOf<T, N, []>) : never;
+export {};

package/lib/common/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/common/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/common/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * For instances where we'd like to define a Tuple to be of certain type and length.\n * Example: TupleOf<number, 3> // [number, number, number]\n *\n * For more example and use cases regarding Recursive conditional types\n * see: https://github.com/microsoft/TypeScript/pull/40002\n */\ntype _TupleOf<T, N extends number, R extends unknown[]> = R[\"length\"] extends N ? R : _TupleOf<T, N, [T, ...R]>;\nexport type TupleOf<T, N extends number> = N extends N ? (number extends N ? T[] : _TupleOf<T, N, []>) : never;\n"]}

package/lib/common/validate.d.ts

@@ -0,0 +1,14 @@
+import "reflect-metadata";
+import { Guard } from "./typeguards";
+export declare function guard<T>(predicate: Guard<T>): (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function validate(target: Object, key: string | symbol, descriptor: PropertyDescriptor): void;
+/**
+ * Checks whether given value is assignable to provided type.
+ */
+export declare function isValueOfType(value: unknown, type: any): boolean;
+/**
+ * Returns type string of a value. It mostly mimics the behavior of typeof, but for non-primitives
+ * (i.e. objects and functions), it returns a more granular type name where possible. Source:
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof#custom_method_that_gets_a_more_specific_type
+ */
+export declare function getTypeName(value: unknown): string;

package/lib/common/validate.js

@@ -0,0 +1,104 @@
+import "reflect-metadata";
+const predicateMetadataKey = Symbol("validate");
+// A map of primitive types accoring to
+/* eslint-disable max-len */
+// http://blog.wolksoftware.com/decorators-metadata-reflection-in-typescript-from-novice-to-expert-part-4#3-basic-type-serialization_1
+const primitiveMap = {
+    string: String,
+    number: Number,
+    boolean: Boolean,
+};
+const ordinalSuffixMap = {
+    1: "st",
+    2: "nd",
+    3: "rd",
+};
+function getArgumentInfo(target, methodName, argumentIndex, arg) {
+    var _a;
+    let argString;
+    try {
+        argString = JSON.stringify(arg);
+    }
+    catch (_b) {
+        argString = String(arg);
+    }
+    return {
+        argPosition: `${argumentIndex + 1}${(_a = ordinalSuffixMap[argumentIndex + 1]) !== null && _a !== void 0 ? _a : "th"}`,
+        methodPath: `${getTypeName(target)}.${String(methodName)}()`,
+        argTypeName: getTypeName(arg),
+        argString,
+    };
+}
+export function guard(predicate) {
+    return (target, propertyKey, parameterIndex) => {
+        let existingPredicates = Reflect.getOwnMetadata(predicateMetadataKey, target, propertyKey) || [];
+        existingPredicates[parameterIndex] = predicate;
+        Reflect.defineMetadata(predicateMetadataKey, existingPredicates, target, propertyKey);
+    };
+}
+export function validate(target, key, descriptor) {
+    const method = descriptor.value;
+    const types = Reflect.getMetadata("design:paramtypes", target, key);
+    const predicates = Reflect.getMetadata(predicateMetadataKey, target, key);
+    descriptor.value = function (...args) {
+        for (const [i, type] of types.entries()) {
+            let arg = Array.isArray(args) && args[i];
+            if (!!predicates && predicates[i] && !predicates[i](arg)) {
+                const { methodPath, argPosition, argString } = getArgumentInfo(target, key, i, arg);
+                throw new Error(`The ${argPosition} argument to ${methodPath} method has an invalid value: ${argString}.`);
+            }
+            if (arg === undefined || arg === null) {
+                // TODO: is there a way to check for nullable parameter?
+                break;
+            }
+            if (!isValueOfType(arg, type)) {
+                const { methodPath, argPosition, argTypeName } = getArgumentInfo(target, key, i, arg);
+                throw new Error(`The ${argPosition} argument to '${methodPath}' method is of type ` +
+                    `'${argTypeName}', which is not assignable to parameter of type '${type.name}'.`);
+            }
+        }
+        return method.apply(this, arguments);
+    };
+}
+/**
+ * Checks whether given value is assignable to provided type.
+ */
+export function isValueOfType(value, type) {
+    if (value instanceof type) {
+        return true;
+    }
+    // test for primitive value
+    const isPrimitive = value !== Object(value);
+    return isPrimitive && primitiveMap[typeof value] === type;
+}
+/* eslint-disable max-len */
+/**
+ * Returns type string of a value. It mostly mimics the behavior of typeof, but for non-primitives
+ * (i.e. objects and functions), it returns a more granular type name where possible. Source:
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof#custom_method_that_gets_a_more_specific_type
+ */
+export function getTypeName(value) {
+    if (typeof value !== "object" && typeof value !== "function") {
+        return typeof value;
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (Object.getPrototypeOf(value) === Function.prototype && /^class/.test(String(value))) {
+        return "class";
+    }
+    // Symbol.toStringTag often specifies the "display name" of the
+    // object's class.
+    if (Symbol.toStringTag in value && typeof value[Symbol.toStringTag] === "string") {
+        return value[Symbol.toStringTag];
+    }
+    // The name of the constructor; for example `Array`, `GeneratorFunction`,
+    // `Number`, `String`, `Boolean` or `MyCustomObject`
+    if (typeof value.constructor.name === "string" && value.constructor.name !== "") {
+        return value.constructor.name;
+    }
+    // At this point there's no robust way to get the type of value,
+    // so we use the base implementation.
+    return typeof value;
+}
+//# sourceMappingURL=validate.js.map

package/lib/common/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../src/common/validate.ts"],"names":[],"mappings":"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","sourcesContent":["import \"reflect-metadata\";\nimport { Guard } from \"./typeguards\";\n\nconst predicateMetadataKey = Symbol(\"validate\");\n\n// A map of primitive types accoring to\n/* eslint-disable max-len */\n// http://blog.wolksoftware.com/decorators-metadata-reflection-in-typescript-from-novice-to-expert-part-4#3-basic-type-serialization_1\nconst primitiveMap = {\n    string: String,\n    number: Number,\n    boolean: Boolean,\n};\n\nconst ordinalSuffixMap = {\n    1: \"st\",\n    2: \"nd\",\n    3: \"rd\",\n};\n\nfunction getArgumentInfo(target: Object, methodName: string | symbol, argumentIndex: number, arg: unknown) {\n    let argString;\n    try {\n        argString = JSON.stringify(arg);\n    } catch {\n        argString = String(arg);\n    }\n    return {\n        argPosition: `${argumentIndex + 1}${ordinalSuffixMap[argumentIndex + 1] ?? \"th\"}`,\n        methodPath: `${getTypeName(target)}.${String(methodName)}()`,\n        argTypeName: getTypeName(arg),\n        argString,\n    };\n}\n\nexport function guard<T>(predicate: Guard<T>) {\n    return (target: Object, propertyKey: string | symbol, parameterIndex: number) => {\n        let existingPredicates: Array<Guard<any>> =\n            Reflect.getOwnMetadata(predicateMetadataKey, target, propertyKey) || [];\n        existingPredicates[parameterIndex] = predicate;\n        Reflect.defineMetadata(predicateMetadataKey, existingPredicates, target, propertyKey);\n    };\n}\n\nexport function validate(target: Object, key: string | symbol, descriptor: PropertyDescriptor): void {\n    const method = descriptor.value!;\n    const types = Reflect.getMetadata(\"design:paramtypes\", target, key);\n    const predicates = Reflect.getMetadata(predicateMetadataKey, target, key);\n    descriptor.value = function (...args: unknown[]) {\n        for (const [i, type] of types.entries()) {\n            let arg = Array.isArray(args) && args[i];\n\n            if (!!predicates && predicates[i] && !predicates[i](arg)) {\n                const { methodPath, argPosition, argString } = getArgumentInfo(target, key, i, arg);\n                throw new Error(\n                    `The ${argPosition} argument to ${methodPath} method has an invalid value: ${argString}.`\n                );\n            }\n            if (arg === undefined || arg === null) {\n                // TODO: is there a way to check for nullable parameter?\n                break;\n            }\n            if (!isValueOfType(arg, type)) {\n                const { methodPath, argPosition, argTypeName } = getArgumentInfo(target, key, i, arg);\n                throw new Error(\n                    `The ${argPosition} argument to '${methodPath}' method is of type ` +\n                        `'${argTypeName}', which is not assignable to parameter of type '${type.name}'.`\n                );\n            }\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * Checks whether given value is assignable to provided type.\n */\nexport function isValueOfType(value: unknown, type: any) {\n    if (value instanceof type) {\n        return true;\n    }\n    // test for primitive value\n    const isPrimitive = value !== Object(value);\n    return isPrimitive && primitiveMap[typeof value] === type;\n}\n\n/* eslint-disable max-len */\n/**\n * Returns type string of a value. It mostly mimics the behavior of typeof, but for non-primitives\n * (i.e. objects and functions), it returns a more granular type name where possible. Source:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof#custom_method_that_gets_a_more_specific_type\n */\nexport function getTypeName(value: unknown): string {\n    if (typeof value !== \"object\" && typeof value !== \"function\") {\n        return typeof value;\n    }\n    if (value === null) {\n        return \"null\";\n    }\n\n    if (Object.getPrototypeOf(value) === Function.prototype && /^class/.test(String(value))) {\n        return \"class\";\n    }\n\n    // Symbol.toStringTag often specifies the \"display name\" of the\n    // object's class.\n    if (Symbol.toStringTag in value && typeof value[Symbol.toStringTag] === \"string\") {\n        return value[Symbol.toStringTag];\n    }\n\n    // The name of the constructor; for example `Array`, `GeneratorFunction`,\n    // `Number`, `String`, `Boolean` or `MyCustomObject`\n    if (typeof value.constructor.name === \"string\" && value.constructor.name !== \"\") {\n        return value.constructor.name;\n    }\n\n    // At this point there's no robust way to get the type of value,\n    // so we use the base implementation.\n    return typeof value;\n}\n"]}

package/lib/configuration.d.ts

@@ -0,0 +1,92 @@
+import { EstimatedLensPerformance } from "./benchmark/estimateLensPerformanceCluster";
+import { LogLevelName } from "./logger/logger";
+interface CameraKitRuntimeConfiguration {
+    lensPerformance: EstimatedLensPerformance | Promise<EstimatedLensPerformance>;
+    logger: "noop" | "console";
+    logLevel: LogLevelName;
+    shouldUseWorker: boolean;
+}
+/**
+ * Configuration which must be provided when calling {@link bootstrapCameraKit}. These values are used to create various
+ * CameraKit components.
+ *
+ * @category Bootstrapping and Configuration
+ */
+export interface CameraKitBootstrapConfiguration {
+    /**
+     * Long-lived token granting your application access to CameraKit APIs. This is found in the SnapKit Dev Portal,
+     * where it's called the API Token.
+     */
+    apiToken: string;
+    /**
+     * 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.
+     */
+    logger?: "noop" | "console";
+    /**
+     * 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;
+    /**
+     * 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
+     * low-performance devices).
+     *
+     * Running the {@link estimateLensPerformance} function will run benchmarks and estimate an appropriate lens
+     * performance cluster (i.e. a performance rating) based on the current environment.
+     *
+     * Lower cluster = worse expected performance capability.
+     *
+     * @example
+     * ```ts
+     * import { bootstrapCameraKit, estimateLensPerformance } from '@snap/camera-kit`
+     *
+     * const cameraKit = await bootstrapCameraKit({
+     *   apiToken: '...',
+     *   lensPerformance: estimateLensPerformance(),
+     * })
+     * ```
+     */
+    lensPerformance?: EstimatedLensPerformance | Promise<EstimatedLensPerformance>;
+    /**
+     * In recommended production deployments, the WebAssembly assets required by CameraKit will be downloaded from an
+     * optimized CDN. But sometimes (e.g. during development or within a CI pipeline), it may be necessary to download
+     * these assets from somewhere else.
+     *
+     * This configuration option allows the application to specify URLs to be used for both the WebAssembly and JS glue
+     * file that are used to run and interact with CameraKit's rendering engine.
+     */
+    lensCoreOverrideUrls?: {
+        wasm: string;
+        js: string;
+    };
+    /**
+     * In recommended production deployments, the WebAssembly assets required by CameraKit will be downloaded from an
+     * optimized CDN. But sometimes during development or within a CI pipeline, it may be necessary to download these
+     * assets from somewhere else. With a provided `wasmEndpointOverride`, asset URLs will be automatically generated
+     * based on this root endpoint.
+     */
+    wasmEndpointOverride?: string;
+}
+/**
+ * This type represents the result of merging user-supplied config with default config -- as such, it has no nullable
+ * fields, making it a more convenient type for other components to use.
+ *
+ * @internal
+ */
+export declare type CameraKitConfiguration = CameraKitRuntimeConfiguration & CameraKitBootstrapConfiguration;
+/** @internal */
+export declare const configurationToken = "configuration";
+/** @internal */
+export declare const createCameraKitConfigurationFactory: (configuration: CameraKitBootstrapConfiguration) => {
+    (): CameraKitConfiguration;
+    token: "configuration";
+    dependencies: [];
+};
+export {};