open-lisp 2026.306.224346

package/esm/src/oml2ast.js

@@ -0,0 +1,258 @@
+function tokenize(str) {
+    //console.debug("tokenize", str);
+    const re = /[\s,]*([()\[\]{}'`]|"(?:\\.|[^\\"])*"|[$]?@(?:@@|[^@])*@|;.*|#[!# ].*|#lang[ ]+.*|#[\|][\s\S]+?[\|]#|#[a-z]+|[^\s,()\[\]{}'"`;@]*)/g;
+    const result = [];
+    let token;
+    while ((token = re.exec(str)[1]) !== "") {
+        //console.debug(`token=${token}`);
+        if (token[0] === ";")
+            continue;
+        if (token.startsWith("#!"))
+            continue;
+        if (token.startsWith("##"))
+            continue;
+        if (token.startsWith("# "))
+            continue;
+        if (token.startsWith("#lang "))
+            continue;
+        if (token.startsWith("#|") && !token.startsWith("#|@"))
+            continue;
+        if (!token.startsWith("#@") && !token.startsWith("#|") &&
+            token.startsWith("#"))
+            token = token.substring(1);
+        if (isFinite(token))
+            token = parseFloat(token, 10);
+        result.push(token);
+    }
+    return result;
+}
+function read_token(code, exp) {
+    if (code.length === 0)
+        return undefined;
+    const token = code.shift();
+    exp.push(token);
+    return token;
+}
+function read_list(code, exp, ch) {
+    const result = [];
+    let ast;
+    while ((ast = read_sexp(code, exp, false)) !== undefined) {
+        if (ast === "]") {
+            if (ch !== "[")
+                code.unshift("]");
+            break;
+        }
+        else if (ast === ")") {
+            break;
+        }
+        result.push(ast);
+    }
+    return result;
+}
+function read_dict(code, exp) {
+    const result = [["#", "dict"]];
+    let ast1;
+    let ast2;
+    while ((ast1 = read_sexp(code, exp)) !== undefined) {
+        if (ast1 === "]")
+            continue;
+        if (ast1 === "}")
+            break;
+        ast2 = read_sexp(code, exp);
+        result.push(ast1);
+        result.push(ast2);
+    }
+    return result;
+}
+function read_sexp(code, exp) {
+    let token = read_token(code, exp);
+    if (token === undefined)
+        return undefined;
+    if ((typeof token) === "number")
+        return token;
+    switch (token) {
+        case "false":
+            return false;
+        case "true":
+            return true;
+        case "null":
+            return null;
+        case "undefined":
+            return ["@", "undefined"];
+    }
+    let ch = token[0];
+    if (ch == "#")
+        ch = token.slice(0, 2);
+    if (token.startsWith("$@")) {
+        ch = "$@";
+    }
+    switch (ch) {
+        case "(":
+        case "[": {
+            const lst = read_list(code, exp, ch);
+            return lst;
+        }
+        case ")":
+        case "]":
+            return ch;
+        case "{":
+            return read_dict(code, exp);
+        case "}":
+            return ch;
+        case '"':
+            token = token.replaceAll("\r\n", "\n");
+            token = token.replaceAll("\n", "\\n");
+            token = JSON.parse(token);
+            return token;
+        case "@":
+            token = token.replace(/(^@|@$)/g, "");
+            token = token.replace(/(@@)/g, "@");
+            token = token.trim();
+            return ["@", token];
+        case "#|": {
+            if (token.startsWith("#|@")) {
+                token = token.replace(/^#[\|]@/g, "");
+                token = token.replace(/[\|]#$/g, "");
+                token = token.trim();
+                return ["@", token];
+            }
+            // not a "#|@" quoted string – handle as in the default branch
+            if (token[0] === ":")
+                return token;
+            if (token[0] === "&")
+                return token;
+            const ids = token[0] === "." ? [token] : token.split(".");
+            return ["#", ...ids];
+        }
+        case "$@": // template literal string
+            token = token.replaceAll("\r\n", "\n");
+            token = token.replace(/(^[$]@|@$)/g, "");
+            token = token.replace(/(@@)/g, "@");
+            return ["$@", token];
+        default: {
+            //if (token[0] === ":") return token;
+            //if (token[0] === "&") return token;
+            if (!token.match(/^[_a-zA-Z][._a-zA-Z0-9]*$/)) {
+                //console.debug(`token=${token} does not match the identifier pattern`);
+                return ["#", token];
+            }
+            const ids = token[0] === "." ? [token] : token.split(".");
+            return ["#", ...ids];
+        }
+    }
+}
+function join_sexp(exp) {
+    if (exp.length === 0)
+        return "";
+    let last = exp.shift();
+    let result = "" + last;
+    while (exp.length > 0) {
+        let token = exp.shift();
+        if (token !== ")" &&
+            token !== "]" &&
+            (last !== "(") & (last !== "[") &&
+            last !== "'") {
+            result += " ";
+        }
+        if (token === "[")
+            token = "(";
+        if (token === "]")
+            token = ")";
+        result += token;
+        last = token;
+    }
+    return result;
+}
+export function oml2ast(text) {
+    const code = tokenize(text);
+    const result = [];
+    while (true) {
+        const exp = [];
+        const ast = read_sexp(code, exp);
+        if (ast === undefined)
+            break;
+        if (ast === ")")
+            continue;
+        if (ast === "]")
+            continue;
+        result.push([join_sexp(exp), ast]);
+    }
+    return result;
+}
+export function ast2oml(ast) {
+    if (ast === null)
+        return "null";
+    if (ast === undefined)
+        return "undefined";
+    if ((typeof ast) === "number")
+        return JSON.stringify(ast);
+    if ((typeof ast) === "string")
+        return JSON.stringify(ast);
+    if ((typeof ast) === "boolean")
+        return JSON.stringify(ast);
+    if (ast instanceof Array) {
+        let result = "( ";
+        for (let i = 0; i < ast.length; i++) {
+            if (i > 0)
+                result += " ";
+            result += ast2oml(ast[i]);
+        }
+        let keys = Object.keys(ast);
+        const re = /^[0-9]+/;
+        keys = keys.filter((key) => !re.test(key));
+        keys.sort();
+        if (keys.length > 0) {
+            if (ast.length > 0)
+                result += " ";
+            result += "?";
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                result += " (";
+                result += JSON.stringify(key);
+                result += " ";
+                result += ast2oml(ast[key]);
+                result += ")";
+            }
+        }
+        result += " )";
+        return result;
+    }
+    else {
+        let result = "{ ";
+        const keys = Object.keys(ast);
+        keys.sort();
+        for (let i = 0; i < keys.length; i++) {
+            if (i > 0)
+                result += " ";
+            result += JSON.stringify(keys[i]);
+            result += " ";
+            result += ast2oml(ast[keys[i]]);
+        }
+        result += " }";
+        return result;
+    }
+}
+export function astequal(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a instanceof Function || b instanceof Function) {
+        return false;
+    }
+    else if (typeof a === "object" && typeof b === "object") {
+        const ak = Object.keys(a);
+        const bk = Object.keys(b);
+        if (ak.length !== bk.length) {
+            return false;
+        }
+        for (let i = 0; i < ak.length; ++i) {
+            const key = ak[i];
+            const ret = astequal(a[key], b[key]);
+            if (ret === false) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}

package/esm/src/omlcommon.d.ts

@@ -0,0 +1,17 @@
+export class OMLCommon {
+    is_array(x: any): x is any[];
+    is_bool(x: any): x is boolean;
+    is_number(x: any): x is number;
+    is_string(x: any): x is string;
+    is_quoted(x: any): boolean;
+    is_id(ast: any, name?: undefined): boolean;
+    is_variable(ast: any): boolean;
+    is_script(ast: any): boolean;
+    is_template(ast: any): boolean;
+    is_callable(ast: any): boolean;
+    is_fn(ast: any): boolean;
+    to_id(ast: any): any;
+    id(x: any): any[];
+    to_def(ast: any): any;
+}
+//# sourceMappingURL=omlcommon.d.ts.map

package/esm/src/omlcommon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omlcommon.d.ts","sourceRoot":"","sources":["../../src/src/omlcommon.js"],"names":[],"mappings":"AAAA;IACE,6BAEC;IAED,8BAEC;IAED,+BAEC;IAED,+BAEC;IAED,2BAIC;IAED,2CAKC;IAED,+BAIC;IAED,6BAIC;IAED,+BAIC;IAED,+BAMC;IAED,yBAIC;IAED,qBAQC;IAED,kBAEC;IAED,sBAuCC;CAEF"}

package/esm/src/omlcommon.js

@@ -0,0 +1,128 @@
+export class OMLCommon {
+    is_array(x) {
+        return (x instanceof Array);
+    }
+    is_bool(x) {
+        return (typeof x) === "boolean";
+    }
+    is_number(x) {
+        return (typeof x) === "number";
+    }
+    is_string(x) {
+        return (typeof x) === "string";
+    }
+    is_quoted(x) {
+        if (!this.is_array(x))
+            return false;
+        if (x.length === 0)
+            return false;
+        return x[0] === "`";
+    }
+    is_id(ast, name = undefined) {
+        const ok = ast instanceof Array && ast[0] === "#";
+        if (!ok)
+            return false;
+        if (name !== undefined)
+            return ast.length > 1 && ast[1] === name;
+        return true;
+    }
+    is_variable(ast) {
+        if (!(ast instanceof Array))
+            return false;
+        if (ast.length === 0)
+            return false;
+        return ast[0] === "#";
+    }
+    is_script(ast) {
+        if (!(ast instanceof Array))
+            return false;
+        if (ast.length === 0)
+            return false;
+        return ast[0] === "@";
+    }
+    is_template(ast) {
+        if (!(ast instanceof Array))
+            return false;
+        if (ast.length === 0)
+            return false;
+        return ast[0] === "$@";
+    }
+    is_callable(ast) {
+        if (!(ast instanceof Array))
+            return false;
+        if (ast.length === 0)
+            return false;
+        if (ast[0] === "#")
+            return false;
+        if (ast[0] === "@")
+            return false;
+        return this.is_id(ast[0]) || this.is_script(ast[0]);
+    }
+    is_fn(ast) {
+        if (!(ast instanceof Array))
+            return false;
+        if (ast.length === 0)
+            return false;
+        return this.is_id(ast[0]) && this.to_id(ast[0]) === "fn";
+    }
+    to_id(ast) {
+        if (this.is_id(ast)) {
+            const ids = ast.slice(1);
+            return ids.join(".");
+        }
+        else if (this.is_script(ast)) {
+            return "<script>";
+        }
+        return ast;
+    }
+    id(x) {
+        return ["#", x];
+    }
+    to_def(ast) {
+        if (!this.is_array(ast))
+            return null;
+        if (ast.length === 0)
+            return null;
+        switch (this.to_id(ast[0])) {
+            case "def": {
+                if (ast.length < 2)
+                    throw new Error("syntax error");
+                const ast1 = ast[1];
+                const ast2 = ast.length === 2 ? null : ast[2];
+                return [this.id("def"), ast1, ast2];
+            }
+            case "defvar": {
+                if (ast.length < 2)
+                    throw new Error("syntax error");
+                const ast1 = ast[1];
+                const ast2 = ast.length === 2 ? null : ast[2];
+                return [this.id("def"), ast1, ast2];
+            }
+            case "defun": {
+                if (ast.length < 3)
+                    throw new Error("syntax error");
+                const new_ast = ast.slice(3);
+                new_ast.unshift(ast[2]);
+                new_ast.unshift(this.id("fn"));
+                return [this.id("def"), ast[1], new_ast];
+            }
+            case "define": {
+                const ast1 = this.to_id(ast[1]);
+                if (ast1 instanceof Array) {
+                    if (ast.length < 2)
+                        throw new Error("syntax error");
+                    const new_ast = ast.slice(2);
+                    return this.to_def([this.id("defun"), ast[1][0], ast[1].slice(1), ...new_ast]);
+                }
+                else {
+                    if (ast.length < 2)
+                        throw new Error("syntax error");
+                    const ast2 = ast.length === 2 ? null : ast[2];
+                    return this.to_def([this.id("defvar"), ast[1], ast2]);
+                }
+            }
+            default:
+                return null;
+        }
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "open-lisp",
+  "version": "2026.0306.224346",
+  "description": "A LISP-1 implementation",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm-module/open-lisp.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/npm-module/open-lisp/issues"
+  },
+  "main": "./script/mod.js",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
+    }
+  },
+  "scripts": {
+    "test": "node test_runner.js"
+  },
+  "dependencies": {
+    "js-beautify": "1.15.4",
+    "@deno/shim-deno": "~0.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0",
+    "picocolors": "^1.0.0"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/_dnt.polyfills.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    interface ArrayConstructor {
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | Promise<T>> | ArrayLike<T | Promise<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+    }
+}
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/script/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,gBAAgB;QACxB,SAAS,CAAC,CAAC,EACP,mBAAmB,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAC7F,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;QAEhB,SAAS,CAAC,CAAC,EAAE,CAAC,EACV,mBAAmB,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,EAClE,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,EAC/B,OAAO,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;KAC1B;CACF;AAoID,OAAO,EAAE,CAAC"}

package/script/_dnt.polyfills.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// From https://github.com/es-shims/array-from-async/blob/4a5ff83947b861f35b380d5d4f20da2f07698638/index.mjs
+// Tried to have dnt depend on the package instead, but it distributes as an
+// ES module, so doesn't work with CommonJS.
+//
+// Code below:
+//
+// Copyright 2021 J. S. Choi
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// **This software is provided by the copyright holders and contributors
+// "as is" and any express or implied warranties, including, but not
+// limited to, the implied warranties of merchantability and fitness for a
+// particular purpose are disclaimed. In no event shall the copyright
+// holder or contributors be liable for any direct, indirect, incidental,
+// special, exemplary, or consequential damages (including, but not limited
+// to, procurement of substitute goods or services; loss of use, data, or
+// profits; or business interruption) however caused and on any theory of
+// liability, whether in contract, strict liability, or tort (including
+// negligence or otherwise) arising in any way out of the use of this
+// software, even if advised of the possibility of such damage.**
+const { MAX_SAFE_INTEGER } = Number;
+const iteratorSymbol = Symbol.iterator;
+const asyncIteratorSymbol = Symbol.asyncIterator;
+const IntrinsicArray = Array;
+const tooLongErrorMessage = 'Input is too long and exceeded Number.MAX_SAFE_INTEGER times.';
+function isConstructor(obj) {
+    if (obj != null) {
+        const prox = new Proxy(obj, {
+            construct() {
+                return prox;
+            },
+        });
+        try {
+            new prox;
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    else {
+        return false;
+    }
+}
+async function fromAsync(items, mapfn, thisArg) {
+    const itemsAreIterable = (asyncIteratorSymbol in items ||
+        iteratorSymbol in items);
+    if (itemsAreIterable) {
+        const result = isConstructor(this)
+            ? new this
+            : IntrinsicArray(0);
+        let i = 0;
+        for await (const v of items) {
+            if (i > MAX_SAFE_INTEGER) {
+                throw TypeError(tooLongErrorMessage);
+            }
+            else if (mapfn) {
+                result[i] = await mapfn.call(thisArg, v, i);
+            }
+            else {
+                result[i] = v;
+            }
+            i++;
+        }
+        result.length = i;
+        return result;
+    }
+    else {
+        // In this case, the items are assumed to be an arraylike object with
+        // a length property and integer properties for each element.
+        const { length } = items;
+        const result = isConstructor(this)
+            ? new this(length)
+            : IntrinsicArray(length);
+        let i = 0;
+        while (i < length) {
+            if (i > MAX_SAFE_INTEGER) {
+                throw TypeError(tooLongErrorMessage);
+            }
+            const v = await items[i];
+            if (mapfn) {
+                result[i] = await mapfn.call(thisArg, v, i);
+            }
+            else {
+                result[i] = v;
+            }
+            i++;
+        }
+        result.length = i;
+        return result;
+    }
+}
+if (!Array.fromAsync) {
+    Array.fromAsync = fromAsync;
+}

package/script/_dnt.shims.d.ts

@@ -0,0 +1,6 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/script/_dnt.shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/_dnt.test_shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.test_shims.d.ts","sourceRoot":"","sources":["../src/_dnt.test_shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/script/deps/jsr.io/@std/assert/1.0.19/almost_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"almost_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/almost_equals.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,GAAG,CAAC,EAAE,MAAM,QAmBb"}

package/script/deps/jsr.io/@std/assert/1.0.19/array_includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_includes.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/array_includes.ts"],"names":[],"mappings":"AAMA,0FAA0F;AAC1F,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAOpD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EACzB,GAAG,CAAC,EAAE,MAAM,GACX,IAAI,CAgCN"}

package/script/deps/jsr.io/@std/assert/1.0.19/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/assert.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAI5D"}

package/script/deps/jsr.io/@std/assert/1.0.19/assertion_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/assertion_error.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

package/script/deps/jsr.io/@std/assert/1.0.19/equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/equal.ts"],"names":[],"mappings":"AA0FA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAgHrD"}

package/script/deps/jsr.io/@std/assert/1.0.19/equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/equals.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QAmBb"}

package/script/deps/jsr.io/@std/assert/1.0.19/exists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/exists.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC,CAOlC"}

package/script/deps/jsr.io/@std/assert/1.0.19/fail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fail.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/fail.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAGxC"}

package/script/deps/jsr.io/@std/assert/1.0.19/false.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"false.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.19/false.ts"],"names":[],"mappings":"AAIA,uDAAuD;AACvD,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;AAE3D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,IAAI,KAAK,CAI1E"}