@stackframe/stack-shared 2.8.1 → 2.8.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @stackframe/stack-shared
 
+## 2.8.2
+
+### Patch Changes
+
+- Various changes
+
 ## 2.8.1
 
 ## 2.8.0

package/dist/interface/clientInterface.d.ts

@@ -6,11 +6,11 @@ import { Result } from "../utils/results";
 import { ContactChannelsCrud } from './crud/contact-channels';
 import { CurrentUserCrud } from './crud/current-user';
 import { ConnectedAccountAccessTokenCrud } from './crud/oauth';
+import { ProjectPermissionsCrud } from './crud/project-permissions';
 import { InternalProjectsCrud, ProjectsCrud } from './crud/projects';
 import { SessionsCrud } from './crud/sessions';
 import { TeamInvitationCrud } from './crud/team-invitation';
 import { TeamMemberProfilesCrud } from './crud/team-member-profiles';
-import { ProjectPermissionsCrud } from './crud/project-permissions';
 import { TeamPermissionsCrud } from './crud/team-permissions';
 import { TeamsCrud } from './crud/teams';
 export type ClientInterfaceOptions = {

package/dist/interface/clientInterface.js

@@ -85,7 +85,7 @@ export class StackClientInterface {
         // try to diagnose the error for the user
         if (retriedResult.status === "error") {
             if (globalVar.navigator && !globalVar.navigator.onLine) {
-                throw new Error("Failed to send Stack network request. It seems like you are offline. (window.navigator.onLine is falsy)", { cause: retriedResult.error });
+                throw new Error("Failed to send Stack network request. It seems like you are offline, please check your internet connection and try again. This is not an error with Stack Auth. (window.navigator.onLine is falsy)", { cause: retriedResult.error });
             }
             throw await this._createNetworkError(retriedResult.error, session, requestType);
         }

package/dist/interface/webhooks.d.ts

@@ -254,4 +254,36 @@ export declare const webhookEvents: readonly [{
         description: string;
         tags: string[];
     };
+}, {
+    type: string;
+    schema: yup.ObjectSchema<{
+        id: string;
+        user_id: string;
+        team_id: string;
+    }, yup.AnyObject, {
+        id: undefined;
+        user_id: undefined;
+        team_id: undefined;
+    }, "">;
+    metadata: {
+        summary: string;
+        description: string;
+        tags: string[];
+    };
+}, {
+    type: string;
+    schema: yup.ObjectSchema<{
+        id: string;
+        user_id: string;
+        team_id: string;
+    }, yup.AnyObject, {
+        id: undefined;
+        user_id: undefined;
+        team_id: undefined;
+    }, "">;
+    metadata: {
+        summary: string;
+        description: string;
+        tags: string[];
+    };
 }];

package/dist/interface/webhooks.js

@@ -1,4 +1,5 @@
 import { teamMembershipCreatedWebhookEvent, teamMembershipDeletedWebhookEvent } from "./crud/team-memberships";
+import { teamPermissionCreatedWebhookEvent, teamPermissionDeletedWebhookEvent } from "./crud/team-permissions";
 import { teamCreatedWebhookEvent, teamDeletedWebhookEvent, teamUpdatedWebhookEvent } from "./crud/teams";
 import { userCreatedWebhookEvent, userDeletedWebhookEvent, userUpdatedWebhookEvent } from "./crud/users";
 export const webhookEvents = [
@@ -10,4 +11,6 @@ export const webhookEvents = [
     teamDeletedWebhookEvent,
     teamMembershipCreatedWebhookEvent,
     teamMembershipDeletedWebhookEvent,
+    teamPermissionCreatedWebhookEvent,
+    teamPermissionDeletedWebhookEvent,
 ];

package/dist/known-errors.d.ts

@@ -66,6 +66,9 @@ export declare const KnownErrors: {
     ProjectAuthenticationError: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
         errorCode: "PROJECT_AUTHENTICATION_ERROR";
     };
+    PermissionIdAlreadyExists: KnownErrorConstructor<KnownError & KnownErrorBrand<"PERMISSION_ID_ALREADY_EXISTS">, [permissionId: string]> & {
+        errorCode: "PERMISSION_ID_ALREADY_EXISTS";
+    };
     InvalidProjectAuthentication: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & {
         constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
     } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {

package/dist/known-errors.js

@@ -570,6 +570,13 @@ const InvalidPollingCodeError = createKnownErrorConstructor(KnownError, "INVALID
     "The polling code is invalid or does not exist.",
     details,
 ], (json) => [json]);
+const PermissionIdAlreadyExists = createKnownErrorConstructor(KnownError, "PERMISSION_ID_ALREADY_EXISTS", (permissionId) => [
+    400,
+    `Permission with ID "${permissionId}" already exists. Choose a different ID.`,
+    {
+        permission_id: permissionId,
+    },
+], (json) => [json.permission_id]);
 export const KnownErrors = {
     CannotDeleteCurrentSession,
     UnsupportedError,
@@ -577,6 +584,7 @@ export const KnownErrors = {
     SchemaError,
     AllOverloadsFailed,
     ProjectAuthenticationError,
+    PermissionIdAlreadyExists,
     InvalidProjectAuthentication,
     ProjectKeyWithoutAccessType,
     InvalidAccessType,

package/dist/utils/errors.js

@@ -68,11 +68,7 @@ StackAssertionError.prototype.name = "StackAssertionError";
 export function errorToNiceString(error) {
     if (!(error instanceof Error))
         return `${typeof error}<${nicify(error)}>`;
-    let stack = error.stack ?? "";
-    const toString = error.toString();
-    if (!stack.startsWith(toString))
-        stack = `${toString}\n${stack}`; // some browsers don't include the error message in the stack, some do
-    return `${stack} ${nicify(Object.fromEntries(Object.entries(error)), { maxDepth: 8 })}`;
+    return nicify(error, { maxDepth: 8 });
 }
 const errorSinks = new Set();
 export function registerErrorSink(sink) {

package/dist/utils/results.js

@@ -1,5 +1,5 @@
 import { wait } from "./promises";
-import { deindent } from "./strings";
+import { deindent, nicify } from "./strings";
 export const Result = {
     fromThrowing,
     fromThrowingAsync,
@@ -255,17 +255,17 @@ import.meta.vitest?.test("mapResult", ({ expect }) => {
 });
 class RetryError extends AggregateError {
     constructor(errors) {
-        const strings = errors.map(e => String(e));
+        const strings = errors.map(e => nicify(e));
         const isAllSame = strings.length > 1 && strings.every(s => s === strings[0]);
         super(errors, deindent `
       Error after ${errors.length} attempts.
       
       ${isAllSame ? deindent `
         Attempts 1-${errors.length}:
-          ${errors[0]}
-      ` : errors.map((e, i) => deindent `
+          ${strings[0]}
+      ` : strings.map((s, i) => deindent `
           Attempt ${i + 1}:
-            ${e}
+            ${s}
         `).join("\n\n")}
       `, { cause: errors[errors.length - 1] });
         this.errors = errors;

package/dist/utils/strings.d.ts

@@ -43,6 +43,7 @@ export declare function trimLines(s: string): string;
 export declare function templateIdentity(strings: TemplateStringsArray | readonly string[], ...values: string[]): string;
 export declare function deindent(code: string): string;
 export declare function deindent(strings: TemplateStringsArray | readonly string[], ...values: any[]): string;
+export declare function deindentTemplate(strings: TemplateStringsArray | readonly string[], ...values: any[]): [string[], ...string[]];
 export declare function extractScopes(scope: string, removeDuplicates?: boolean): string[];
 export declare function mergeScopeStrings(...scopes: string[]): string;
 export declare function escapeTemplateLiteral(s: string): string;

package/dist/utils/strings.js

@@ -207,8 +207,9 @@ Line2`).toBe("Line1\nLine2");
 export function deindent(strings, ...values) {
     if (typeof strings === "string")
         return deindent([strings]);
-    if (strings.length === 0)
-        return "";
+    return templateIdentity(...deindentTemplate(strings, ...values));
+}
+export function deindentTemplate(strings, ...values) {
     if (values.length !== strings.length - 1)
         throw new StackAssertionError("Invalid number of values; must be one less than strings", { strings, values });
     const trimmedStrings = [...strings];
@@ -231,7 +232,7 @@ export function deindent(strings, ...values) {
         const firstLineIndentation = getWhitespacePrefix(deindentedStrings[i].split("\n").at(-1));
         return `${value}`.replaceAll("\n", `\n${firstLineIndentation}`);
     });
-    return templateIdentity(deindentedStrings, ...indentedValues);
+    return [deindentedStrings, ...indentedValues];
 }
 import.meta.vitest?.test("deindent", ({ expect }) => {
     // Test with string input
@@ -241,7 +242,6 @@ import.meta.vitest?.test("deindent", ({ expect }) => {
     expect(deindent("\n  hello\n  world\n")).toBe("hello\nworld");
     // Test with empty input
     expect(deindent("")).toBe("");
-    expect(deindent([])).toBe("");
     // Test with template literal
     expect(deindent `
     hello
@@ -414,12 +414,13 @@ export function nicify(value, options = {}) {
         keyInParent: null,
         hideFields: [],
     };
-    const nestedNicify = (newValue, newPath, keyInParent) => {
+    const nestedNicify = (newValue, newPath, keyInParent, options = {}) => {
         return nicify(newValue, {
             ...newOptions,
             path: newPath,
             currentIndent: currentIndent + lineIndent,
             keyInParent,
+            ...options,
         });
     };
     switch (typeof value) {
@@ -431,7 +432,7 @@ export function nicify(value, options = {}) {
             const isDeindentable = (v) => deindent(v) === v && v.includes("\n");
             const wrapInDeindent = (v) => deindent `
         deindent\`
-        ${currentIndent + lineIndent}${escapeTemplateLiteral(value).replaceAll("\n", nl + lineIndent)}
+        ${currentIndent + lineIndent}${escapeTemplateLiteral(v).replaceAll("\n", nl + lineIndent)}
         ${currentIndent}\`
       `;
             if (isDeindentable(value)) {
@@ -470,7 +471,7 @@ export function nicify(value, options = {}) {
                 resValues.push(...extraLines);
                 if (resValues.length !== resValueLength)
                     throw new StackAssertionError("nicify of object: resValues.length !== resValueLength", { value, resValues, resValueLength });
-                const shouldIndent = resValues.length > 1 || resValues.some(x => x.includes("\n"));
+                const shouldIndent = resValues.length > 4 || resValues.some(x => (resValues.length > 1 && x.length > 4) || x.includes("\n"));
                 if (shouldIndent) {
                     return `[${nl}${resValues.map(x => `${lineIndent}${x},${nl}`).join("")}]`;
                 }
@@ -479,13 +480,30 @@ export function nicify(value, options = {}) {
                 }
             }
             if (value instanceof URL) {
-                return `URL(${nicify(value.toString())})`;
+                return `URL(${nestedNicify(value.toString(), `${path}.toString()`, null)})`;
             }
             if (ArrayBuffer.isView(value)) {
                 return `${value.constructor.name}([${value.toString()}])`;
             }
+            if (value instanceof Error) {
+                let stack = value.stack ?? "";
+                const toString = value.toString();
+                if (!stack.startsWith(toString))
+                    stack = `${toString}\n${stack}`; // some browsers don't include the error message in the stack, some do
+                stack = stack.trimEnd();
+                stack = stack.replace(/\n\s+/g, `\n${lineIndent}${lineIndent}`);
+                stack = stack.replace("\n", `\n${lineIndent}Stack:\n`);
+                if (Object.keys(value).length > 0) {
+                    stack += `\n${lineIndent}Extra properties: ${nestedNicify(Object.fromEntries(Object.entries(value)), path, null)}`;
+                }
+                if (value.cause) {
+                    stack += `\n${lineIndent}Cause:\n${lineIndent}${lineIndent}${nestedNicify(value.cause, path, null, { currentIndent: currentIndent + lineIndent + lineIndent })}`;
+                }
+                stack = stack.replaceAll("\n", `\n${currentIndent}`);
+                return stack;
+            }
             const constructorName = [null, Object.prototype].includes(Object.getPrototypeOf(value)) ? null : (nicifiableClassNameOverrides.get(value.constructor) ?? value.constructor.name);
-            const constructorString = constructorName ? `${nicifyPropertyString(constructorName)} ` : "";
+            const constructorString = constructorName ? `${constructorName} ` : "";
             const entries = getNicifiableEntries(value).filter(([k]) => !hideFields.includes(k));
             const extraLines = [
                 ...getNicifiedObjectExtraLines(value),
@@ -498,7 +516,7 @@ export function nicify(value, options = {}) {
                 return `${constructorString}{ ... }`;
             const resValues = entries.map(([k, v], keyIndex) => {
                 const keyNicified = nestedNicify(k, `Object.keys(${path})[${keyIndex}]`, null);
-                const keyInObjectLiteral = typeof k === "string" ? JSON.stringify(k) : `[${keyNicified}]`;
+                const keyInObjectLiteral = typeof k === "string" ? nicifyPropertyString(k) : `[${keyNicified}]`;
                 if (typeof v === "function" && v.name === k) {
                     return `${keyInObjectLiteral}(...): { ... }`;
                 }
@@ -525,25 +543,63 @@ export function nicify(value, options = {}) {
     }
 }
 export function replaceAll(input, searchValue, replaceValue) {
+    if (searchValue === "")
+        throw new StackAssertionError("replaceAll: searchValue is empty");
     return input.split(searchValue).join(replaceValue);
 }
+import.meta.vitest?.test("replaceAll", ({ expect }) => {
+    expect(replaceAll("hello world", "o", "x")).toBe("hellx wxrld");
+    expect(replaceAll("aaa", "a", "b")).toBe("bbb");
+    expect(replaceAll("", "a", "b")).toBe("");
+    expect(replaceAll("abc", "b", "")).toBe("ac");
+    expect(replaceAll("test.test.test", ".", "_")).toBe("test_test_test");
+    expect(replaceAll("a.b*c", ".", "x")).toBe("axb*c");
+    expect(replaceAll("a*b*c", "*", "x")).toBe("axbxc");
+    expect(replaceAll("hello hello", "hello", "hi")).toBe("hi hi");
+});
 function nicifyPropertyString(str) {
-    if (/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(str))
-        return str;
     return JSON.stringify(str);
 }
+import.meta.vitest?.test("nicifyPropertyString", ({ expect }) => {
+    // Test valid identifiers
+    expect(nicifyPropertyString("validName")).toBe('"validName"');
+    expect(nicifyPropertyString("_validName")).toBe('"_validName"');
+    expect(nicifyPropertyString("valid123Name")).toBe('"valid123Name"');
+    // Test invalid identifiers
+    expect(nicifyPropertyString("123invalid")).toBe('"123invalid"');
+    expect(nicifyPropertyString("invalid-name")).toBe('"invalid-name"');
+    expect(nicifyPropertyString("invalid space")).toBe('"invalid space"');
+    expect(nicifyPropertyString("$invalid")).toBe('"$invalid"');
+    expect(nicifyPropertyString("")).toBe('""');
+    // Test with special characters
+    expect(nicifyPropertyString("property!")).toBe('"property!"');
+    expect(nicifyPropertyString("property.name")).toBe('"property.name"');
+    // Test with escaped characters
+    expect(nicifyPropertyString("\\")).toBe('"\\\\"');
+    expect(nicifyPropertyString('"')).toBe('"\\""');
+});
 function getNicifiableKeys(value) {
     const overridden = ("getNicifiableKeys" in value ? value.getNicifiableKeys?.bind(value) : null)?.();
     if (overridden != null)
         return overridden;
     const keys = Object.keys(value).sort();
-    if (value instanceof Error) {
-        if (value.cause)
-            keys.unshift("cause");
-        keys.unshift("message", "stack");
-    }
     return unique(keys);
 }
+import.meta.vitest?.test("getNicifiableKeys", ({ expect }) => {
+    // Test regular object
+    expect(getNicifiableKeys({ b: 1, a: 2, c: 3 })).toEqual(["a", "b", "c"]);
+    // Test empty object
+    expect(getNicifiableKeys({})).toEqual([]);
+    // Test object with custom getNicifiableKeys
+    const customObject = {
+        a: 1,
+        b: 2,
+        getNicifiableKeys() {
+            return ["customKey1", "customKey2"];
+        }
+    };
+    expect(getNicifiableKeys(customObject)).toEqual(["customKey1", "customKey2"]);
+});
 function getNicifiableEntries(value) {
     const recordLikes = [Headers];
     function isRecordLike(value) {

package/dist/utils/strings.nicify.test.js

@@ -0,0 +1,214 @@
+import { describe, expect, test } from "vitest";
+import { deindent, nicify } from "./strings";
+describe("nicify", () => {
+    describe("primitive values", () => {
+        test("numbers", () => {
+            expect(nicify(123)).toBe("123");
+            expect(nicify(123n)).toBe("123n");
+        });
+        test("strings", () => {
+            expect(nicify("hello")).toBe('"hello"');
+        });
+        test("booleans", () => {
+            expect(nicify(true)).toBe("true");
+            expect(nicify(false)).toBe("false");
+        });
+        test("null and undefined", () => {
+            expect(nicify(null)).toBe("null");
+            expect(nicify(undefined)).toBe("undefined");
+        });
+        test("symbols", () => {
+            expect(nicify(Symbol("test"))).toBe("Symbol(test)");
+        });
+    });
+    describe("arrays", () => {
+        test("empty array", () => {
+            expect(nicify([])).toBe("[]");
+        });
+        test("single-element array", () => {
+            expect(nicify([1])).toBe("[1]");
+        });
+        test("single-element array with long content", () => {
+            expect(nicify(["123123123123123"])).toBe('["123123123123123"]');
+        });
+        test("flat array", () => {
+            expect(nicify([1, 2, 3])).toBe("[1, 2, 3]");
+        });
+        test("longer array", () => {
+            expect(nicify([10000, 2, 3])).toBe(deindent `
+        [
+          10000,
+          2,
+          3,
+        ]
+      `);
+        });
+        test("nested array", () => {
+            expect(nicify([1, [2, 3]])).toBe(deindent `
+        [
+          1,
+          [2, 3],
+        ]
+      `);
+        });
+    });
+    describe("objects", () => {
+        test("empty object", () => {
+            expect(nicify({})).toBe("{}");
+        });
+        test("simple object", () => {
+            expect(nicify({ a: 1 })).toBe('{ "a": 1 }');
+        });
+        test("multiline object", () => {
+            expect(nicify({ a: 1, b: 2 })).toBe(deindent `
+        {
+          "a": 1,
+          "b": 2,
+        }
+      `);
+        });
+    });
+    describe("custom classes", () => {
+        test("class instance", () => {
+            class TestClass {
+                constructor(value) {
+                    this.value = value;
+                }
+            }
+            expect(nicify(new TestClass(42))).toBe('TestClass { "value": 42 }');
+        });
+    });
+    describe("built-in objects", () => {
+        test("URL", () => {
+            expect(nicify(new URL("https://example.com"))).toBe('URL("https://example.com/")');
+        });
+        test("TypedArrays", () => {
+            expect(nicify(new Uint8Array([1, 2, 3]))).toBe("Uint8Array([1,2,3])");
+            expect(nicify(new Int32Array([1, 2, 3]))).toBe("Int32Array([1,2,3])");
+        });
+        test("Error objects", () => {
+            const error = new Error("test error");
+            const nicifiedError = nicify({ error });
+            expect(nicifiedError).toMatch(new RegExp(deindent `
+        ^\{
+          "error": Error: test error
+            Stack:
+              at (.|\\n)*
+        \}$
+      `));
+        });
+        test("Error objects with cause and an extra property", () => {
+            const error = new Error("test error", { cause: new Error("cause") });
+            error.extra = "something";
+            const nicifiedError = nicify(error, { lineIndent: "--" });
+            expect(nicifiedError).toMatch(new RegExp(deindent `
+        ^Error: test error
+        --Stack:
+        ----at (.|\\n)+
+        --Extra properties: \{ "extra": "something" \}
+        --Cause:
+        ----Error: cause
+        ------Stack:
+        --------at (.|\\n)+$
+      `));
+        });
+        test("Headers", () => {
+            const headers = new Headers();
+            headers.append("Content-Type", "application/json");
+            headers.append("Accept", "text/plain");
+            expect(nicify(headers)).toBe(deindent `
+        Headers {
+          "accept": "text/plain",
+          "content-type": "application/json",
+        }`);
+        });
+    });
+    describe("multiline strings", () => {
+        test("basic multiline", () => {
+            expect(nicify("line1\nline2")).toBe('deindent`\n  line1\n  line2\n`');
+        });
+        test("multiline with trailing newline", () => {
+            expect(nicify("line1\nline2\n")).toBe('deindent`\n  line1\n  line2\n` + "\\n"');
+        });
+    });
+    describe("circular references", () => {
+        test("object with self reference", () => {
+            const circular = { a: 1 };
+            circular.self = circular;
+            expect(nicify(circular)).toBe(deindent `
+        {
+          "a": 1,
+          "self": Ref<value>,
+        }`);
+        });
+    });
+    describe("configuration options", () => {
+        test("maxDepth", () => {
+            const deep = { a: { b: { c: { d: { e: 1 } } } } };
+            expect(nicify(deep, { maxDepth: 2 })).toBe('{ "a": { "b": { ... } } }');
+        });
+        test("lineIndent", () => {
+            expect(nicify({ a: 1, b: 2 }, { lineIndent: "    " })).toBe(deindent `
+        {
+            "a": 1,
+            "b": 2,
+        }
+      `);
+        });
+        test("hideFields", () => {
+            expect(nicify({ a: 1, b: 2, secret: "hidden" }, { hideFields: ["secret"] })).toBe(deindent `
+        {
+          "a": 1,
+          "b": 2,
+          <some fields may have been hidden>,
+        }
+      `);
+        });
+    });
+    describe("custom overrides", () => {
+        test("override with custom type", () => {
+            expect(nicify({ type: "special" }, {
+                overrides: ((value) => {
+                    if (typeof value === "object" && value && "type" in value && value.type === "special") {
+                        return "SPECIAL";
+                    }
+                    return null;
+                })
+            })).toBe("SPECIAL");
+        });
+    });
+    describe("functions", () => {
+        test("named function", () => {
+            expect(nicify(function namedFunction() { })).toBe("function namedFunction(...) { ... }");
+        });
+        test("arrow function", () => {
+            expect(nicify(() => { })).toBe("(...) => { ... }");
+        });
+    });
+    describe("Nicifiable interface", () => {
+        test("object implementing Nicifiable", () => {
+            const nicifiable = {
+                value: 42,
+                getNicifiableKeys() {
+                    return ["value"];
+                },
+                getNicifiedObjectExtraLines() {
+                    return ["// custom comment"];
+                }
+            };
+            expect(nicify(nicifiable)).toBe(deindent `
+        {
+          "value": 42,
+          // custom comment,
+        }
+      `);
+        });
+    });
+    describe("unknown types", () => {
+        test("object without prototype", () => {
+            const unknownType = Object.create(null);
+            unknownType.value = "test";
+            expect(nicify(unknownType)).toBe('{ "value": "test" }');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.8.1",
+  "version": "2.8.2",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",

package/dist/utils/strings.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { templateIdentity } from "./strings";
-describe("templateIdentity", () => {
-    it("should be equivalent to a regular template string", () => {
-        const adjective = "scientific";
-        const noun = "railgun";
-        expect(templateIdentity `a certain scientific railgun`).toBe("a certain scientific railgun");
-        expect(templateIdentity `a certain ${adjective} railgun`).toBe(`a certain scientific railgun`);
-        expect(templateIdentity `a certain ${adjective} ${noun}`).toBe(`a certain scientific railgun`);
-        expect(templateIdentity `${adjective}${noun}`).toBe(`scientificrailgun`);
-    });
-    it("should work with empty strings", () => {
-        expect(templateIdentity ``).toBe("");
-        expect(templateIdentity `${""}`).toBe("");
-        expect(templateIdentity `${""}${""}`).toBe("");
-    });
-    it("should work with normal arrays", () => {
-        expect(templateIdentity(["a ", " scientific ", "gun"], "certain", "rail")).toBe("a certain scientific railgun");
-        expect(templateIdentity(["a"])).toBe("a");
-    });
-    it("should throw an error with wrong number of value arguments", () => {
-        expect(() => templateIdentity([])).toThrow();
-        expect(() => templateIdentity(["a", "b"])).toThrow();
-        expect(() => templateIdentity(["a", "b", "c"], "a", "b", "c")).toThrow();
-    });
-});