@goast/typescript 0.4.3 → 0.4.4

package/esm/src/ast/nodes/tuple.test.js

@@ -0,0 +1,33 @@
+import "../../../_dnt.test_polyfills.js";
+import { normalizeEOL } from '@goast/test-utils';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsTuple } from './tuple.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsTuple', () => {
+    it('should write empty tuple if no elements are provided', () => {
+        builder.append(tsTuple([]));
+        expect(builder.toString(false)).toBe('[]');
+    });
+    it('should write the elements', () => {
+        builder.append(tsTuple(['string', 'number']));
+        expect(builder.toString(false)).toBe('[string, number]');
+    });
+    it('should write multiline if there are more than 3 elements', () => {
+        builder.append(tsTuple(['string', 'number', 'boolean', 'unknown']));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`[
+          string,
+          number,
+          boolean,
+          unknown
+        ]`));
+    });
+    it('should write as const', () => {
+        builder.append(tsTuple(['string', 'number'], { asConst: true }));
+        expect(builder.toString(false)).toBe('[string, number] as const');
+    });
+});

package/esm/src/ast/nodes/type-alias.test.d.ts

@@ -0,0 +1,2 @@
+import "../../../_dnt.test_polyfills.js";
+//# sourceMappingURL=type-alias.test.d.ts.map

package/esm/src/ast/nodes/type-alias.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-alias.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/type-alias.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/type-alias.test.js

@@ -0,0 +1,27 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/expect.js';
+import { beforeEach, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsGenericParameter } from './generic-parameter.js';
+import { tsTypeAlias } from './type-alias.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+it('should write the name of the type alias', () => {
+    builder.append(tsTypeAlias('X', 'number'));
+    expect(builder.toString(false)).toBe('type X = number;' + EOL);
+});
+it('should write the generics if they exist', () => {
+    builder.append(tsTypeAlias('X', 'number', { generics: [tsGenericParameter('T'), tsGenericParameter('U')] }));
+    expect(builder.toString(false)).toBe('type X<T, U> = number;' + EOL);
+});
+it('should write export keyword if configured', () => {
+    builder.append(tsTypeAlias('X', 'number', { export: true }));
+    expect(builder.toString(false)).toBe('export type X = number;' + EOL);
+});
+it('should render injections', () => {
+    builder.append(tsTypeAlias('X', 'number', { inject: { before: ['before'], after: ['after'] } }));
+    expect(builder.toString(false)).toBe(`beforetype X = number;${EOL}after`);
+});

package/esm/src/ast/nodes/union-type.test.d.ts

@@ -0,0 +1,2 @@
+import "../../../_dnt.test_polyfills.js";
+//# sourceMappingURL=union-type.test.d.ts.map

package/esm/src/ast/nodes/union-type.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-type.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/union-type.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/union-type.test.js

@@ -0,0 +1,38 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsUnionType } from './union-type.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+describe('tsUnionType', () => {
+    it('should write type "never" if no types are provided', () => {
+        builder.append(tsUnionType([]));
+        expect(builder.toString(false)).toBe('never');
+    });
+    it('should write the type if only one type is provided', () => {
+        builder.append(tsUnionType(['string']));
+        expect(builder.toString(false)).toBe('string');
+    });
+    it('should write the types', () => {
+        builder.append(tsUnionType(['string', 'number']));
+        expect(builder.toString(false)).toBe('(string) | (number)');
+    });
+    it('should write the types on separate lines if there are more than 3', () => {
+        builder.append(tsUnionType(['string', 'number', 'boolean', 'unknown']));
+        expect(builder.toString(false)).toBe(`${EOL}| (string)${EOL}| (number)${EOL}| (boolean)${EOL}| (unknown)`);
+    });
+    it('should collapse nested union types', () => {
+        builder.append(tsUnionType([tsUnionType(['string', 'number']), tsUnionType(['boolean', 'unknown'])]));
+        expect(builder.toString(false)).toBe(`${EOL}| (string)${EOL}| (number)${EOL}| (boolean)${EOL}| (unknown)`);
+    });
+    it('should render injections', () => {
+        builder.append(tsUnionType(['string', 'number'], {
+            inject: { before: '║b║', after: '║a║' },
+        }));
+        expect(builder.toString(false)).toBe('║b║(string) | (number)║a║');
+    });
+});

package/esm/src/ast/nodes/variable.test.d.ts

@@ -0,0 +1,2 @@
+import "../../../_dnt.test_polyfills.js";
+//# sourceMappingURL=variable.test.d.ts.map

package/esm/src/ast/nodes/variable.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variable.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/variable.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/variable.test.js

@@ -0,0 +1,38 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.12/expect.js';
+import { beforeEach, it } from '../../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { tsVariable } from './variable.js';
+let builder;
+beforeEach(() => {
+    builder = new TypeScriptFileBuilder();
+});
+it('should write the name of the variable', () => {
+    builder.append(tsVariable('x'));
+    expect(builder.toString(false)).toBe('let x;' + EOL);
+});
+it('should write the type if it exists', () => {
+    builder.append(tsVariable('x', { type: 'number' }));
+    expect(builder.toString(false)).toBe('let x: number;' + EOL);
+});
+it('should write the value if it exists', () => {
+    builder.append(tsVariable('x', { value: 42 }));
+    expect(builder.toString(false)).toBe('let x = 42;' + EOL);
+});
+it('should write the const keyword if configured', () => {
+    builder.append(tsVariable('x', { readonly: true }));
+    expect(builder.toString(false)).toBe('const x;' + EOL);
+});
+it('should write the export keyword if configured', () => {
+    builder.append(tsVariable('x', { export: true }));
+    expect(builder.toString(false)).toBe('export let x;' + EOL);
+});
+it('should write all the parts of the variable', () => {
+    builder.append(tsVariable('x', { type: 'number', value: 42, readonly: true, export: true }));
+    expect(builder.toString(false)).toBe('export const x: number = 42;' + EOL);
+});
+it('should render injections', () => {
+    builder.append(tsVariable('x', { inject: { before: ['before'], after: ['after'] } }));
+    expect(builder.toString(false)).toBe(`beforelet x;${EOL}after`);
+});

package/esm/src/generators/services/angular-services/angular-service-generator.js

@@ -232,13 +232,13 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
                     }
                     : null,
                 '',
-                s `return ${ctx.refs.waitForResponse([responseModelType])}(${s.indent `
-              this.http.request(rb.build({${s.indent `
-                responseType: ${ts.string(responseType)},
-                accept: ${ts.string(accept)},
-                context,`}
-              })),
-              {${s.indent `
+                s `return ${ctx.refs.waitForResponse([responseModelType])}(${s.indent `
+              this.http.request(rb.build({${s.indent `
+                responseType: ${ts.string(responseType)},
+                accept: ${ts.string(accept)},
+                context,`}
+              })),
+              {${s.indent `
                 errorResponseTypes: ${ts.object({
                     members: [
                         ...Object.entries(this.getEndpointStatusCodes(ctx, endpoint))
@@ -247,8 +247,8 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
                             return ts.property(key, { value: ts.string(value.parser) });
                         }),
                     ],
-                })}`}
-              }`}
+                })}`}
+              }`}
             )`,
             ], '\n'),
         });

package/esm/src/generators/services/easy-network-stub/easy-network-stub-generator.js

@@ -94,15 +94,15 @@ export class DefaultTypeScriptEasyNetworkStubGenerator extends TypeScriptFileGen
             ],
             returnType: 'this',
             body: appendValueGroup([
-                s `this.stubWrapper.stub2<${requestType}>()(${s.indent `
-              ${ts.string(endpoint.method.toUpperCase())},
-              ${this.getStubClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)},
-              async (request) => {${s.indent `
-                if (this.stubWrapper.options.rememberRequests) {${s.indent `
-                  this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.push(request);`}
-                }
-                throw await response(${this.getResponderVariableName(ctx, endpoint)}, request);`}
-              }`}
+                s `this.stubWrapper.stub2<${requestType}>()(${s.indent `
+              ${ts.string(endpoint.method.toUpperCase())},
+              ${this.getStubClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)},
+              async (request) => {${s.indent `
+                if (this.stubWrapper.options.rememberRequests) {${s.indent `
+                  this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.push(request);`}
+                }
+                throw await response(${this.getResponderVariableName(ctx, endpoint)}, request);`}
+              }`}
             );`,
                 'return this;',
             ], '\n'),

package/esm/src/generators/services/fetch-clients/fetch-client-generator.js

@@ -131,7 +131,7 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
         const method = this.getInterfaceEndpointMethod(ctx, endpoint);
         method.accessModifier = 'public';
         method.body = appendValueGroup([
-            s `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${s.indent `
+            s `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${s.indent `
           .withPath(${ts.string(endpoint.path)})${(b) => b.forEach(endpoint.parameters, (b, p) => {
                 switch (p.target) {
                     case 'path':
@@ -141,7 +141,7 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
                         b.append(s `\n.withQueryParam(${ts.string(p.name)}, params.${toCasing(p.name, ctx.config.paramNameCasing)})`);
                         break;
                 }
-            })}
+            })}
           .build();`}`,
             s `const response = (this.options.fetch ?? fetch)(url, ${ts.object({
                 members: [

package/esm/src/generators/services/k6-clients/k6-client-generator.js

@@ -188,7 +188,7 @@ export class DefaultTypeScriptK6ClientGenerator extends TypeScriptFileGenerator
                         ],
                     }),
                     parameters: [ts.constructorParameter('rootUrl'), ts.constructorParameter('defaultK6ParamsFactory')],
-                    body: s `this.rootUrl = rootUrl;
+                    body: s `this.rootUrl = rootUrl;
                   this._defaultK6ParamsFactory = defaultK6ParamsFactory;`,
                 }),
                 ...ctx.service.endpoints.map((e) => this.getEndpointMethod(ctx, e)),
@@ -249,11 +249,11 @@ export class DefaultTypeScriptK6ClientGenerator extends TypeScriptFileGenerator
                     }
                     : null,
                 '',
-                s `return /** @type {${returnType}} */ (${s.indent `
-              ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${s.indent `
-                accept: ${ts.string(accept)},
-                params: this.getK6Params(k6Params),`}
-              })`}
+                s `return /** @type {${returnType}} */ (${s.indent `
+              ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${s.indent `
+                accept: ${ts.string(accept)},
+                params: this.getK6Params(k6Params),`}
+              })`}
             );`,
             ], '\n'),
         });

package/esm/src/import-collection.test.d.ts

@@ -0,0 +1,2 @@
+import "../_dnt.test_polyfills.js";
+//# sourceMappingURL=import-collection.test.d.ts.map

package/esm/src/import-collection.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-collection.test.d.ts","sourceRoot":"","sources":["../../src/src/import-collection.test.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC"}

package/esm/src/import-collection.test.js

@@ -0,0 +1,64 @@
+import "../_dnt.test_polyfills.js";
+import { expect } from '../deps/jsr.io/@std/expect/1.0.12/mod.js';
+import { beforeEach, describe, it } from '../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { ImportExportCollection } from './import-collection.js';
+describe('ImportExportCollection', () => {
+    let collection;
+    let sourceBuilderOptions;
+    beforeEach(() => {
+        collection = new ImportExportCollection({ importModuleTransformer: 'omit-extension' });
+        sourceBuilderOptions = { newLine: '\n' };
+    });
+    describe('addImport', () => {
+        it('should add a new import to the collection', () => {
+            collection.addImport('myImport', 'myModule');
+            expect(collection.hasImports).toBe(true);
+            expect(collection.hasExports).toBe(false);
+            expect(collection.toString(sourceBuilderOptions)).toBe("import { myImport } from 'myModule';\n");
+        });
+        it('should add a new import to an existing module', () => {
+            collection.addImport('myImport1', 'myModule');
+            collection.addImport('myImport2', 'myModule');
+            expect(collection.hasImports).toBe(true);
+            expect(collection.hasExports).toBe(false);
+            expect(collection.toString(sourceBuilderOptions)).toBe("import { myImport1, myImport2 } from 'myModule';\n");
+        });
+    });
+    describe('addExport', () => {
+        it('should add a new export to the collection', () => {
+            collection.addExport('myExport', 'myModule');
+            expect(collection.hasImports).toBe(false);
+            expect(collection.hasExports).toBe(true);
+            expect(collection.toString(sourceBuilderOptions)).toBe("export { myExport } from 'myModule';\n");
+        });
+        it('should add a new export to an existing module', () => {
+            collection.addExport('myExport1', 'myModule');
+            collection.addExport('myExport2', 'myModule');
+            expect(collection.hasImports).toBe(false);
+            expect(collection.hasExports).toBe(true);
+            expect(collection.toString(sourceBuilderOptions)).toBe("export { myExport1, myExport2 } from 'myModule';\n");
+        });
+    });
+    describe('clear', () => {
+        it('should clear the collection', () => {
+            collection.addImport('myImport', 'myModule');
+            collection.addExport('myExport', 'myModule');
+            expect(collection.hasImports).toBe(true);
+            expect(collection.hasExports).toBe(true);
+            collection.clear();
+            expect(collection.hasImports).toBe(false);
+            expect(collection.hasExports).toBe(false);
+            expect(collection.toString(sourceBuilderOptions)).toBe('');
+        });
+    });
+    describe('toString', () => {
+        it('should return an empty string if the collection is empty', () => {
+            expect(collection.toString(sourceBuilderOptions)).toBe('');
+        });
+        it('should return a string representation of the collection', () => {
+            collection.addImport('myImport', 'myModule');
+            collection.addExport('myExport', 'myModule');
+            expect(collection.toString(sourceBuilderOptions)).toBe("import { myImport } from 'myModule';\n\nexport { myExport } from 'myModule';\n");
+        });
+    });
+});

package/esm/tests/openapi-models.test.d.ts

@@ -0,0 +1,2 @@
+import "../_dnt.test_polyfills.js";
+//# sourceMappingURL=openapi-models.test.d.ts.map

package/esm/tests/openapi-models.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-models.test.d.ts","sourceRoot":"","sources":["../../src/tests/openapi-models.test.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC"}

package/esm/tests/openapi-models.test.js

@@ -0,0 +1,45 @@
+import "../_dnt.test_polyfills.js";
+import { join } from 'node:path';
+import fs from 'fs-extra';
+import { OpenApiGenerator, toCustomCase } from '@goast/core';
+import { MultipartData, openApiV2FilesDir, openApiV3_1FilesDir, openApiV3FilesDir, verify, } from '@goast/test-utils';
+import { afterEach, describe, test } from '../deps/jsr.io/@std/testing/1.0.9/bdd.js';
+import { restore, stub } from '../deps/jsr.io/@std/testing/1.0.9/mock.js';
+import { TypeScriptModelsGenerator } from '../src/generators/models/models-generator.js';
+const filePaths = {
+    '2.0': openApiV2FilesDir,
+    '3.0': openApiV3FilesDir,
+    '3.1': openApiV3_1FilesDir,
+};
+const testFilesAllVersions = ['simple-schemas.yml', 'detailed-schemas.yml', 'object-schemas.yml'];
+const testFilesV3x = ['oneof-schemas.yml', 'discriminated-schemas.yml'];
+for (const [version, path] of Object.entries(filePaths)) {
+    describe(`OpenAPI V${version}`, () => {
+        afterEach(() => {
+            restore();
+        });
+        const testFiles = version.startsWith('3') ? testFilesAllVersions.concat(testFilesV3x) : testFilesAllVersions;
+        for (const file of testFiles) {
+            const fileWithoutExt = file.replace(/\.[^/.]+$/, '');
+            test(toCustomCase(fileWithoutExt, { wordCasing: 'all-lower', wordSeparator: ' ' }), async (t) => {
+                const filePath = join(path, file);
+                const result = new MultipartData();
+                stub(fs, 'ensureDirSync');
+                stub(fs, 'writeFileSync', (path, data) => {
+                    result.push([path.toString(), data.toString()]);
+                });
+                const generatorOptions = {
+                    outputDir: 'out',
+                    newLine: '\n',
+                };
+                const state = await new OpenApiGenerator(generatorOptions)
+                    // deno-lint-ignore no-explicit-any
+                    .useType(TypeScriptModelsGenerator, { __test__: true })
+                    .parseAndGenerate(filePath);
+                result.splice(0, 0, ['state', state]);
+                restore();
+                await verify(t, result);
+            });
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goast/typescript",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Provides gOAst generators for generating TypeScript code from OpenAPI specifications.",
   "author": {
     "name": "Marc Schmidt (MaSch0212)",
@@ -28,7 +28,7 @@
   "dependencies": {
     "tslib": "^2.6.2",
     "fs-extra": "^11.2.0",
-    "@goast/core": "0.4.0"
+    "@goast/core": "0.4.1"
   },
   "devDependencies": {
     "@types/node": "^20.9.0",

package/script/_dnt.test_polyfills.d.ts

@@ -0,0 +1,29 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};
+declare global {
+    interface String {
+        /**
+         * Replace all instances of a substring in a string, using a regular expression or search string.
+         * @param searchValue A string to search for.
+         * @param replaceValue A string containing the text to replace for every successful match of searchValue in this string.
+         */
+        replaceAll(searchValue: string | RegExp, replaceValue: string): string;
+        /**
+         * Replace all instances of a substring in a string, using a regular expression or search string.
+         * @param searchValue A string to search for.
+         * @param replacer A function that returns the replacement text.
+         */
+        replaceAll(searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+    }
+}
+export {};
+//# sourceMappingURL=_dnt.test_polyfills.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.test_polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.test_polyfills.ts"],"names":[],"mappings":"AAeA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd;;;;WAIG;QACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;KAC5C;CACF;AAED,OAAO,EAAE,CAAC;AACV,OAAO,CAAC,MAAM,CAAC;IAEb,UAAU,MAAM;QACd;;;;WAIG;QACH,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;QAEvE;;;;WAIG;QACH,UAAU,CACR,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,GACtD,MAAM,CAAC;KACX;CACF;AAsBD,OAAO,EAAE,CAAC"}

package/script/_dnt.test_polyfills.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
+/**
+ * String.prototype.replaceAll() polyfill
+ * https://gomakethings.com/how-to-replace-a-section-of-a-string-with-another-one-with-vanilla-js/
+ * @author Chris Ferdinandi
+ * @license MIT
+ */
+if (!String.prototype.replaceAll) {
+    String.prototype.replaceAll = function (str, newStr) {
+        // If a regex pattern
+        if (Object.prototype.toString.call(str).toLowerCase() === "[object regexp]") {
+            return this.replace(str, newStr);
+        }
+        // If a string
+        return this.replace(new RegExp(str, "g"), newStr);
+    };
+}

package/script/_dnt.test_shims.d.ts

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

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,sBAAsB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAK5C,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/script/_dnt.test_shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_test_1 = require("@deno/shim-deno-test");
+var shim_deno_test_2 = require("@deno/shim-deno-test");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_test_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_test_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/deps/jsr.io/@std/assert/1.0.11/assertion_error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=assertion_error.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.11/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.11/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.11/assertion_error.js

@@ -0,0 +1,34 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertionError = void 0;
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AssertionError";
+    }
+}
+exports.AssertionError = AssertionError;

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

@@ -0,0 +1,17 @@
+/**
+ * Deep equality comparison used in assertions.
+ *
+ * @param a The actual value
+ * @param b The expected value
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @example Usage
+ * ```ts
+ * import { equal } from "@std/assert/equal";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false`
+ * ```
+ */
+export declare function equal(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=equal.d.ts.map

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

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