@alagoni97/cli 0.72.1

package/dist/browser/shims/fs.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Browser shim for Node.js 'fs' module.
+ * Provides stub implementations that throw helpful errors.
+ *
+ * This module is used for both 'fs' and 'fs/promises' imports.
+ * All functions return promises since that's what the browser code expects.
+ */
+declare class FakeStats {
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    size: number;
+    blksize: number;
+    blocks: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export declare const Stats: typeof FakeStats;
+export declare const readFile: (..._args: unknown[]) => Promise<never>;
+export declare const writeFile: (..._args: unknown[]) => Promise<never>;
+export declare const mkdir: (..._args: unknown[]) => Promise<never>;
+export declare const readdir: (..._args: unknown[]) => Promise<never>;
+export declare const stat: (..._args: unknown[]) => Promise<never>;
+export declare const unlink: (..._args: unknown[]) => Promise<never>;
+export declare const rmdir: (..._args: unknown[]) => Promise<never>;
+export declare const access: (..._args: unknown[]) => Promise<never>;
+export declare const copyFile: (..._args: unknown[]) => Promise<never>;
+export declare const rename: (..._args: unknown[]) => Promise<never>;
+export declare const lstat: (..._args: unknown[]) => Promise<never>;
+export declare const realpath: (..._args: unknown[]) => Promise<never>;
+export declare const chmod: (..._args: unknown[]) => Promise<never>;
+export declare const chown: (..._args: unknown[]) => Promise<never>;
+export declare const utimes: (..._args: unknown[]) => Promise<never>;
+export declare const link: (..._args: unknown[]) => Promise<never>;
+export declare const symlink: (..._args: unknown[]) => Promise<never>;
+export declare const readlink: (..._args: unknown[]) => Promise<never>;
+export declare const truncate: (..._args: unknown[]) => Promise<never>;
+export declare const appendFile: (..._args: unknown[]) => Promise<never>;
+export declare const open: (..._args: unknown[]) => Promise<never>;
+export declare const rm: (..._args: unknown[]) => Promise<never>;
+export declare const readFileSync: (..._args: unknown[]) => never;
+export declare const writeFileSync: (..._args: unknown[]) => never;
+export declare const existsSync: () => boolean;
+export declare const mkdirSync: (..._args: unknown[]) => never;
+export declare const readdirSync: () => string[];
+export declare const statSync: () => FakeStats;
+export declare const unlinkSync: (..._args: unknown[]) => never;
+export declare const rmdirSync: (..._args: unknown[]) => never;
+export declare const accessSync: (..._args: unknown[]) => never;
+export declare const copyFileSync: (..._args: unknown[]) => never;
+export declare const renameSync: (..._args: unknown[]) => never;
+export declare const lstatSync: () => FakeStats;
+export declare const realpathSync: (..._args: unknown[]) => never;
+export declare const promises: {
+    readFile: (..._args: unknown[]) => Promise<never>;
+    writeFile: (..._args: unknown[]) => Promise<never>;
+    mkdir: (..._args: unknown[]) => Promise<never>;
+    readdir: (..._args: unknown[]) => Promise<never>;
+    stat: (..._args: unknown[]) => Promise<never>;
+    unlink: (..._args: unknown[]) => Promise<never>;
+    rmdir: (..._args: unknown[]) => Promise<never>;
+    access: (..._args: unknown[]) => Promise<never>;
+    copyFile: (..._args: unknown[]) => Promise<never>;
+    rename: (..._args: unknown[]) => Promise<never>;
+    lstat: (..._args: unknown[]) => Promise<never>;
+    realpath: (..._args: unknown[]) => Promise<never>;
+    chmod: (..._args: unknown[]) => Promise<never>;
+    chown: (..._args: unknown[]) => Promise<never>;
+    utimes: (..._args: unknown[]) => Promise<never>;
+    link: (..._args: unknown[]) => Promise<never>;
+    symlink: (..._args: unknown[]) => Promise<never>;
+    readlink: (..._args: unknown[]) => Promise<never>;
+    truncate: (..._args: unknown[]) => Promise<never>;
+    appendFile: (..._args: unknown[]) => Promise<never>;
+    open: (..._args: unknown[]) => Promise<never>;
+    rm: (..._args: unknown[]) => Promise<never>;
+};
+export declare const constants: {
+    F_OK: number;
+    R_OK: number;
+    W_OK: number;
+    X_OK: number;
+    COPYFILE_EXCL: number;
+    COPYFILE_FICLONE: number;
+    COPYFILE_FICLONE_FORCE: number;
+    O_RDONLY: number;
+    O_WRONLY: number;
+    O_RDWR: number;
+    O_CREAT: number;
+    O_EXCL: number;
+    O_TRUNC: number;
+    O_APPEND: number;
+    O_DIRECTORY: number;
+    O_NOFOLLOW: number;
+    O_SYNC: number;
+    O_DSYNC: number;
+    O_SYMLINK: number;
+    O_NONBLOCK: number;
+};
+declare const _default: {
+    readFile: (..._args: unknown[]) => Promise<never>;
+    writeFile: (..._args: unknown[]) => Promise<never>;
+    mkdir: (..._args: unknown[]) => Promise<never>;
+    readdir: (..._args: unknown[]) => Promise<never>;
+    stat: (..._args: unknown[]) => Promise<never>;
+    unlink: (..._args: unknown[]) => Promise<never>;
+    rmdir: (..._args: unknown[]) => Promise<never>;
+    access: (..._args: unknown[]) => Promise<never>;
+    copyFile: (..._args: unknown[]) => Promise<never>;
+    rename: (..._args: unknown[]) => Promise<never>;
+    readFileSync: (..._args: unknown[]) => never;
+    writeFileSync: (..._args: unknown[]) => never;
+    existsSync: () => boolean;
+    mkdirSync: (..._args: unknown[]) => never;
+    readdirSync: () => string[];
+    statSync: () => FakeStats;
+    unlinkSync: (..._args: unknown[]) => never;
+    rmdirSync: (..._args: unknown[]) => never;
+    accessSync: (..._args: unknown[]) => never;
+    copyFileSync: (..._args: unknown[]) => never;
+    renameSync: (..._args: unknown[]) => never;
+    lstatSync: () => FakeStats;
+    realpathSync: (..._args: unknown[]) => never;
+    lstat: (..._args: unknown[]) => Promise<never>;
+    promises: {
+        readFile: (..._args: unknown[]) => Promise<never>;
+        writeFile: (..._args: unknown[]) => Promise<never>;
+        mkdir: (..._args: unknown[]) => Promise<never>;
+        readdir: (..._args: unknown[]) => Promise<never>;
+        stat: (..._args: unknown[]) => Promise<never>;
+        unlink: (..._args: unknown[]) => Promise<never>;
+        rmdir: (..._args: unknown[]) => Promise<never>;
+        access: (..._args: unknown[]) => Promise<never>;
+        copyFile: (..._args: unknown[]) => Promise<never>;
+        rename: (..._args: unknown[]) => Promise<never>;
+        lstat: (..._args: unknown[]) => Promise<never>;
+        realpath: (..._args: unknown[]) => Promise<never>;
+        chmod: (..._args: unknown[]) => Promise<never>;
+        chown: (..._args: unknown[]) => Promise<never>;
+        utimes: (..._args: unknown[]) => Promise<never>;
+        link: (..._args: unknown[]) => Promise<never>;
+        symlink: (..._args: unknown[]) => Promise<never>;
+        readlink: (..._args: unknown[]) => Promise<never>;
+        truncate: (..._args: unknown[]) => Promise<never>;
+        appendFile: (..._args: unknown[]) => Promise<never>;
+        open: (..._args: unknown[]) => Promise<never>;
+        rm: (..._args: unknown[]) => Promise<never>;
+    };
+    constants: {
+        F_OK: number;
+        R_OK: number;
+        W_OK: number;
+        X_OK: number;
+        COPYFILE_EXCL: number;
+        COPYFILE_FICLONE: number;
+        COPYFILE_FICLONE_FORCE: number;
+        O_RDONLY: number;
+        O_WRONLY: number;
+        O_RDWR: number;
+        O_CREAT: number;
+        O_EXCL: number;
+        O_TRUNC: number;
+        O_APPEND: number;
+        O_DIRECTORY: number;
+        O_NOFOLLOW: number;
+        O_SYNC: number;
+        O_DSYNC: number;
+        O_SYMLINK: number;
+        O_NONBLOCK: number;
+    };
+    Stats: typeof FakeStats;
+};
+export default _default;

package/dist/browser/shims/fs.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * Browser shim for Node.js 'fs' module.
+ * Provides stub implementations that throw helpful errors.
+ *
+ * This module is used for both 'fs' and 'fs/promises' imports.
+ * All functions return promises since that's what the browser code expects.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constants = exports.promises = exports.realpathSync = exports.lstatSync = exports.renameSync = exports.copyFileSync = exports.accessSync = exports.rmdirSync = exports.unlinkSync = exports.statSync = exports.readdirSync = exports.mkdirSync = exports.existsSync = exports.writeFileSync = exports.readFileSync = exports.rm = exports.open = exports.appendFile = exports.truncate = exports.readlink = exports.symlink = exports.link = exports.utimes = exports.chown = exports.chmod = exports.realpath = exports.lstat = exports.rename = exports.copyFile = exports.access = exports.rmdir = exports.unlink = exports.stat = exports.readdir = exports.mkdir = exports.writeFile = exports.readFile = exports.Stats = void 0;
+const notSupportedAsync = (name) => {
+    return (..._args) => {
+        return Promise.reject(new Error(`fs.${name} is not supported in browser environment`));
+    };
+};
+// For sync functions that might be called
+const notSupportedSync = (name) => {
+    return (..._args) => {
+        throw new Error(`fs.${name} is not supported in browser environment`);
+    };
+};
+// Fake Stats object for statSync/lstatSync - returns false for all checks
+class FakeStats {
+    dev = 0;
+    ino = 0;
+    mode = 0;
+    nlink = 0;
+    uid = 0;
+    gid = 0;
+    rdev = 0;
+    size = 0;
+    blksize = 0;
+    blocks = 0;
+    atimeMs = 0;
+    mtimeMs = 0;
+    ctimeMs = 0;
+    birthtimeMs = 0;
+    atime = new Date(0);
+    mtime = new Date(0);
+    ctime = new Date(0);
+    birthtime = new Date(0);
+    isFile() {
+        return false;
+    }
+    isDirectory() {
+        return false;
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isSymbolicLink() {
+        return false;
+    }
+    isFIFO() {
+        return false;
+    }
+    isSocket() {
+        return false;
+    }
+}
+// Singleton fake stats instance
+const fakeStats = new FakeStats();
+// Export Stats class for libraries that reference fs.Stats
+exports.Stats = FakeStats;
+// Async function stubs (used by fs/promises imports)
+exports.readFile = notSupportedAsync('readFile');
+exports.writeFile = notSupportedAsync('writeFile');
+exports.mkdir = notSupportedAsync('mkdir');
+exports.readdir = notSupportedAsync('readdir');
+exports.stat = notSupportedAsync('stat');
+exports.unlink = notSupportedAsync('unlink');
+exports.rmdir = notSupportedAsync('rmdir');
+exports.access = notSupportedAsync('access');
+exports.copyFile = notSupportedAsync('copyFile');
+exports.rename = notSupportedAsync('rename');
+exports.lstat = notSupportedAsync('lstat');
+exports.realpath = notSupportedAsync('realpath');
+exports.chmod = notSupportedAsync('chmod');
+exports.chown = notSupportedAsync('chown');
+exports.utimes = notSupportedAsync('utimes');
+exports.link = notSupportedAsync('link');
+exports.symlink = notSupportedAsync('symlink');
+exports.readlink = notSupportedAsync('readlink');
+exports.truncate = notSupportedAsync('truncate');
+exports.appendFile = notSupportedAsync('appendFile');
+exports.open = notSupportedAsync('open');
+exports.rm = notSupportedAsync('rm');
+// Sync function stubs (used by direct fs imports)
+exports.readFileSync = notSupportedSync('readFileSync');
+exports.writeFileSync = notSupportedSync('writeFileSync');
+const existsSync = () => false;
+exports.existsSync = existsSync;
+exports.mkdirSync = notSupportedSync('mkdirSync');
+const readdirSync = () => [];
+exports.readdirSync = readdirSync;
+// Return fake stats that say "not a file, not a directory" - used by is-directory and similar
+const statSync = () => fakeStats;
+exports.statSync = statSync;
+exports.unlinkSync = notSupportedSync('unlinkSync');
+exports.rmdirSync = notSupportedSync('rmdirSync');
+exports.accessSync = notSupportedSync('accessSync');
+exports.copyFileSync = notSupportedSync('copyFileSync');
+exports.renameSync = notSupportedSync('renameSync');
+// Return fake stats for lstatSync too
+const lstatSync = () => fakeStats;
+exports.lstatSync = lstatSync;
+exports.realpathSync = notSupportedSync('realpathSync');
+// Promises namespace (for `import { promises } from 'fs'`)
+exports.promises = {
+    readFile: exports.readFile,
+    writeFile: exports.writeFile,
+    mkdir: exports.mkdir,
+    readdir: exports.readdir,
+    stat: exports.stat,
+    unlink: exports.unlink,
+    rmdir: exports.rmdir,
+    access: exports.access,
+    copyFile: exports.copyFile,
+    rename: exports.rename,
+    lstat: exports.lstat,
+    realpath: exports.realpath,
+    chmod: exports.chmod,
+    chown: exports.chown,
+    utimes: exports.utimes,
+    link: exports.link,
+    symlink: exports.symlink,
+    readlink: exports.readlink,
+    truncate: exports.truncate,
+    appendFile: exports.appendFile,
+    open: exports.open,
+    rm: exports.rm
+};
+// Constants
+exports.constants = {
+    F_OK: 0,
+    R_OK: 4,
+    W_OK: 2,
+    X_OK: 1,
+    COPYFILE_EXCL: 1,
+    COPYFILE_FICLONE: 2,
+    COPYFILE_FICLONE_FORCE: 4,
+    O_RDONLY: 0,
+    O_WRONLY: 1,
+    O_RDWR: 2,
+    O_CREAT: 64,
+    O_EXCL: 128,
+    O_TRUNC: 512,
+    O_APPEND: 1024,
+    O_DIRECTORY: 65536,
+    O_NOFOLLOW: 131072,
+    O_SYNC: 1052672,
+    O_DSYNC: 4096,
+    O_SYMLINK: 2097152,
+    O_NONBLOCK: 2048
+};
+// Default export (for `import fs from 'fs'`)
+exports.default = {
+    readFile: exports.readFile,
+    writeFile: exports.writeFile,
+    mkdir: exports.mkdir,
+    readdir: exports.readdir,
+    stat: exports.stat,
+    unlink: exports.unlink,
+    rmdir: exports.rmdir,
+    access: exports.access,
+    copyFile: exports.copyFile,
+    rename: exports.rename,
+    readFileSync: exports.readFileSync,
+    writeFileSync: exports.writeFileSync,
+    existsSync: exports.existsSync,
+    mkdirSync: exports.mkdirSync,
+    readdirSync: exports.readdirSync,
+    statSync: exports.statSync,
+    unlinkSync: exports.unlinkSync,
+    rmdirSync: exports.rmdirSync,
+    accessSync: exports.accessSync,
+    copyFileSync: exports.copyFileSync,
+    renameSync: exports.renameSync,
+    lstatSync: exports.lstatSync,
+    realpathSync: exports.realpathSync,
+    lstat: exports.lstat,
+    promises: exports.promises,
+    constants: exports.constants,
+    Stats: exports.Stats
+};

package/dist/browser/shims/json-schema-ref-parser.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Browser shim for @apidevtools/json-schema-ref-parser.
+ * The original library uses Node.js file system APIs for dereferencing.
+ * In the browser, we provide implementations that resolve internal $ref
+ * references (those starting with #/) without file system access.
+ */
+type Schema = any;
+/**
+ * Exported dereferenceInternal for @readme/openapi-parser compatibility.
+ */
+export declare function dereferenceInternal(schema: Schema, _options?: object): Promise<Schema>;
+/**
+ * Browser-compatible dereference that resolves internal $ref references.
+ */
+export declare function dereference(_basePathOrSchema: string | object, schemaOrOptions?: object, _options?: object): Promise<object>;
+/**
+ * Browser-compatible bundle that returns the input unchanged.
+ */
+export declare function bundle(_basePathOrSchema: string | object, schemaOrOptions?: object, _options?: object): Promise<object>;
+/**
+ * Browser-compatible parse that returns the input unchanged.
+ */
+export declare function parse(_basePathOrSchema: string | object, schemaOrOptions?: object, _options?: object): Promise<object>;
+/**
+ * Browser-compatible resolve that returns the input unchanged.
+ */
+export declare function resolve(_basePathOrSchema: string | object, schemaOrOptions?: object, _options?: object): Promise<object>;
+/**
+ * Stub for MissingPointerError
+ */
+export declare class MissingPointerError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Stub for $RefParser class used by @readme/openapi-parser and @apidevtools/swagger-parser
+ * Must be a proper constructor function for util.inherits compatibility
+ */
+export declare function $RefParser(this: RefParserInstance): void;
+interface RefParserInstance {
+    schema: Schema;
+    $refs: {
+        circular: boolean;
+        paths: () => string[];
+        values: () => Record<string, Schema>;
+        get: (path: string) => Schema | undefined;
+    };
+}
+/**
+ * Get default options for json-schema-ref-parser
+ */
+export declare function getJsonSchemaRefParserDefaultOptions(): object;
+/**
+ * Options constructor for swagger-parser compatibility
+ * swagger-parser does: util.inherits(ParserOptions, $RefParserOptions)
+ */
+interface OptionsInstance {
+    parse: object;
+    resolve: object;
+    dereference: object;
+    [key: string]: unknown;
+}
+export declare function Options(this: OptionsInstance, options?: object): void;
+export { Options as $RefParserOptions };
+/**
+ * Normalize arguments for parser methods (used by swagger-parser)
+ */
+export declare function normalizeArgs(args: IArguments | unknown[]): {
+    path: string;
+    schema: Schema;
+    options: object;
+    callback?: (err: Error | null, result?: Schema) => void;
+};
+export default $RefParser;

package/dist/browser/shims/json-schema-ref-parser.js

@@ -0,0 +1,246 @@
+"use strict";
+/* eslint-disable security/detect-object-injection */
+/**
+ * Browser shim for @apidevtools/json-schema-ref-parser.
+ * The original library uses Node.js file system APIs for dereferencing.
+ * In the browser, we provide implementations that resolve internal $ref
+ * references (those starting with #/) without file system access.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeArgs = exports.$RefParserOptions = exports.Options = exports.getJsonSchemaRefParserDefaultOptions = exports.$RefParser = exports.MissingPointerError = exports.resolve = exports.parse = exports.bundle = exports.dereference = exports.dereferenceInternal = void 0;
+/**
+ * Resolve a JSON pointer (e.g., "#/components/messages/UserCreated") within a schema.
+ */
+function resolvePointer(schema, pointer) {
+    if (!pointer.startsWith('#/')) {
+        return undefined; // External refs not supported in browser
+    }
+    const parts = pointer
+        .slice(2)
+        .split('/')
+        .map((p) => 
+    // Decode JSON pointer escape sequences
+    p.replace(/~1/g, '/').replace(/~0/g, '~'));
+    let current = schema;
+    for (const part of parts) {
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Deep clone and dereference all internal $ref in a schema.
+ */
+function dereferenceInternalImpl(schema, root, visited = new Set()) {
+    if (schema === null || typeof schema !== 'object') {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map((item) => dereferenceInternalImpl(item, root, visited));
+    }
+    // Handle $ref
+    if (schema.$ref &&
+        typeof schema.$ref === 'string' &&
+        schema.$ref.startsWith('#/')) {
+        const refPath = schema.$ref;
+        // Prevent circular reference infinite loops
+        if (visited.has(refPath)) {
+            // Return a reference marker for circular refs
+            return { ...schema };
+        }
+        const resolved = resolvePointer(root, refPath);
+        if (resolved !== undefined) {
+            visited.add(refPath);
+            // Recursively dereference the resolved schema
+            const dereferenced = dereferenceInternalImpl(resolved, root, visited);
+            visited.delete(refPath);
+            return dereferenced;
+        }
+    }
+    // Recursively process all properties
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        result[key] = dereferenceInternalImpl(value, root, visited);
+    }
+    return result;
+}
+/**
+ * Exported dereferenceInternal for @readme/openapi-parser compatibility.
+ */
+async function dereferenceInternal(schema, _options) {
+    return dereferenceInternalImpl(schema, schema);
+}
+exports.dereferenceInternal = dereferenceInternal;
+/**
+ * Browser-compatible dereference that resolves internal $ref references.
+ */
+async function dereference(_basePathOrSchema, schemaOrOptions, _options) {
+    const schema = typeof _basePathOrSchema === 'object'
+        ? _basePathOrSchema
+        : schemaOrOptions ?? {};
+    return dereferenceInternalImpl(schema, schema);
+}
+exports.dereference = dereference;
+/**
+ * Browser-compatible bundle that returns the input unchanged.
+ */
+async function bundle(_basePathOrSchema, schemaOrOptions, _options) {
+    if (typeof _basePathOrSchema === 'object') {
+        return _basePathOrSchema;
+    }
+    return schemaOrOptions ?? {};
+}
+exports.bundle = bundle;
+/**
+ * Browser-compatible parse that returns the input unchanged.
+ */
+async function parse(_basePathOrSchema, schemaOrOptions, _options) {
+    if (typeof _basePathOrSchema === 'object') {
+        return _basePathOrSchema;
+    }
+    return schemaOrOptions ?? {};
+}
+exports.parse = parse;
+/**
+ * Browser-compatible resolve that returns the input unchanged.
+ */
+async function resolve(_basePathOrSchema, schemaOrOptions, _options) {
+    if (typeof _basePathOrSchema === 'object') {
+        return _basePathOrSchema;
+    }
+    return schemaOrOptions ?? {};
+}
+exports.resolve = resolve;
+/**
+ * Stub for MissingPointerError
+ */
+class MissingPointerError extends Error {
+    constructor(message) {
+        super(message || 'Missing pointer');
+        this.name = 'MissingPointerError';
+    }
+}
+exports.MissingPointerError = MissingPointerError;
+/**
+ * Stub for $RefParser class used by @readme/openapi-parser and @apidevtools/swagger-parser
+ * Must be a proper constructor function for util.inherits compatibility
+ */
+function $RefParser() {
+    this.schema = {};
+    this.$refs = {
+        circular: false,
+        paths: () => [],
+        values: () => ({}),
+        get: () => undefined
+    };
+}
+exports.$RefParser = $RefParser;
+/**
+ * Normalise the variadic `(pathOrSchema, schemaOrOptions, options)` signature
+ * used by `@apidevtools/json-schema-ref-parser` (and called as
+ * `(path, schema, options)` by `@readme/openapi-parser`) into a single schema
+ * object. Mirrors the standalone `parse`/`dereference`/`bundle`/`resolve`
+ * exports above so the prototype methods don't drift from them.
+ */
+function resolveSchemaFromArgs(pathOrSchema, schemaOrOptions) {
+    if (typeof pathOrSchema === 'object' && pathOrSchema !== null) {
+        return pathOrSchema;
+    }
+    if (typeof schemaOrOptions === 'object' && schemaOrOptions !== null) {
+        return schemaOrOptions;
+    }
+    if (typeof pathOrSchema === 'string') {
+        try {
+            return JSON.parse(pathOrSchema);
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+$RefParser.prototype.parse = async function (pathOrSchema, schemaOrOptions, _options) {
+    this.schema = resolveSchemaFromArgs(pathOrSchema, schemaOrOptions);
+    return this.schema;
+};
+$RefParser.prototype.resolve = async function (pathOrSchema, schemaOrOptions, options) {
+    await this.parse(pathOrSchema, schemaOrOptions, options);
+    return this;
+};
+$RefParser.prototype.bundle = async function (pathOrSchema, schemaOrOptions, options) {
+    await this.parse(pathOrSchema, schemaOrOptions, options);
+    return this.schema;
+};
+$RefParser.prototype.dereference = async function (pathOrSchema, schemaOrOptions, _options) {
+    const schema = resolveSchemaFromArgs(pathOrSchema, schemaOrOptions);
+    this.schema = dereferenceInternalImpl(schema, schema);
+    return this.schema;
+};
+/**
+ * Get default options for json-schema-ref-parser
+ */
+function getJsonSchemaRefParserDefaultOptions() {
+    return {
+        parse: {
+            json: { order: 100 },
+            yaml: { order: 200 },
+            text: { order: 300 },
+            binary: { order: 400 }
+        },
+        resolve: {
+            file: { order: 100 },
+            http: { order: 200 },
+            external: true
+        },
+        dereference: {
+            circular: true,
+            excludedPathMatcher: () => false
+        },
+        continueOnError: false
+    };
+}
+exports.getJsonSchemaRefParserDefaultOptions = getJsonSchemaRefParserDefaultOptions;
+function Options(options) {
+    const defaults = getJsonSchemaRefParserDefaultOptions();
+    Object.assign(this, defaults);
+    if (options) {
+        Object.assign(this, options);
+    }
+}
+exports.Options = Options;
+exports.$RefParserOptions = Options;
+Options.prototype = {};
+/**
+ * Normalize arguments for parser methods (used by swagger-parser)
+ */
+function normalizeArgs(args) {
+    const argsArray = Array.from(args);
+    let path = '';
+    let schema = {};
+    let options = {};
+    let callback;
+    // Parse arguments based on type
+    for (const arg of argsArray) {
+        if (typeof arg === 'string') {
+            path = arg;
+        }
+        else if (typeof arg === 'function') {
+            callback = arg;
+        }
+        else if (typeof arg === 'object' && arg !== null) {
+            if (!schema || Object.keys(schema).length === 0) {
+                schema = arg;
+            }
+            else {
+                options = arg;
+            }
+        }
+    }
+    return { path, schema, options, callback };
+}
+exports.normalizeArgs = normalizeArgs;
+// Default export - must be the $RefParser constructor for CommonJS compatibility
+// swagger-parser does: const $RefParser = require('@apidevtools/json-schema-ref-parser')
+exports.default = $RefParser;