sonamu 0.8.26 → 0.9.0

package/dist/utils/formatter.js

@@ -1,118 +1,92 @@
-import { Biome } from "@biomejs/js-api/nodejs";
-import { Naite } from "../naite/naite.js";
-import { isTest } from "./controller.js";
-const biome = new Biome();
-let projectKey = -1;
-export function setupBiome(path) {
-    if (projectKey !== -1) {
-        return;
-    }
-    projectKey = biome.openProject(path).projectKey;
-    biome.applyConfiguration(projectKey, {
-        formatter: {
-            enabled: true,
-            formatWithErrors: false,
-            indentStyle: "space",
-            indentWidth: 2,
-            lineEnding: "lf",
-            lineWidth: 100,
-            attributePosition: "auto"
-        },
-        linter: {
-            enabled: true,
-            rules: {
-                recommended: true,
-                style: {
-                    useNodejsImportProtocol: "off"
-                },
-                correctness: {
-                    useParseIntRadix: "off",
-                    noEmptyPattern: "off",
-                    noUnusedImports: {
-                        level: "warn",
-                        fix: "safe"
-                    }
-                },
-                a11y: {
-                    noLabelWithoutControl: "off"
-                },
-                complexity: {
-                    noBannedTypes: "off"
-                },
-                suspicious: {
-                    noArrayIndexKey: "off"
-                }
-            }
-        },
-        javascript: {
-            formatter: {
-                jsxQuoteStyle: "double",
-                quoteProperties: "asNeeded",
-                trailingCommas: "all",
-                semicolons: "always",
-                arrowParentheses: "always",
-                bracketSpacing: true,
-                bracketSameLine: false,
-                quoteStyle: "double",
-                attributePosition: "auto"
-            }
-        },
-        json: {
-            formatter: {
-                indentWidth: 2
-            }
-        },
-        assist: {
-            enabled: true,
-            actions: {
-                source: {
-                    organizeImports: "on"
-                }
-            }
-        }
-    });
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { init_controller, isTest } from "./controller.js";
+import { join } from "path";
+import { readFileSync, unlinkSync, writeFileSync } from "fs";
+import { execFileSync } from "child_process";
+import { createRequire } from "module";
+import { format } from "oxfmt";
+
+//#region src/utils/formatter.ts
+function resolveOxlintBin() {
+	try {
+		return _require.resolve("oxlint/bin/oxlint");
+	} catch {
+		return "oxlint";
+	}
 }
-export function formatCode(code, parser, filePath) {
-    Naite.t("formatCode", {
-        code,
-        parser
-    });
-    if (projectKey === -1) {
-        console.warn("Biome is not setup. Please call setupBiome first.");
-        return code;
-    }
-    // 포맷팅을 먼저 해야함
-    const formatted = biome.formatContent(projectKey, code, {
-        filePath
-    });
-    Naite.t("formatCode:formatted", formatted);
-    if (formatted.diagnostics.filter((d)=>d.severity === "error").length > 0) {
-        console.error(formatted.diagnostics);
-        throw new Error("Biome format error");
-    }
-    // 린팅을 그 다음에
-    const linted = biome.lintContent(projectKey, formatted.content, {
-        filePath,
-        fixFileMode: "safeAndUnsafeFixes"
-    });
-    if (linted.diagnostics.filter((d)=>d.severity === "error").length > 0) {
-        Naite.t("formatCode:linted:content", linted.content);
-        Naite.t("formatCode:linted:diagnostics", linted.diagnostics);
-        !isTest() && console.dir(linted.diagnostics, {
-            depth: null
-        });
-        throw new Error("Biome lint error");
-    }
-    Naite.t("formatCode:linted", linted);
-    // 포맷팅 한 번 더 (import 구문에 type 키워드 추가되는 경우 maxWidth 초과로 인한 에러 발생)
-    const formattedAgain = biome.formatContent(projectKey, linted.content, {
-        filePath
-    });
-    if (formattedAgain.diagnostics.filter((d)=>d.severity === "error").length > 0) {
-        console.error(formattedAgain.diagnostics);
-        throw new Error("Biome format error");
-    }
-    return formattedAgain.content;
+async function formatCode(code, parser, _filePath) {
+	const fileName = parser === "json" ? "file.json" : "file.ts";
+	const formatted = await format(fileName, code, OXFMT_OPTIONS);
+	if (formatted.errors.length > 0) {
+		const errorMessages = formatted.errors.filter((e) => e.severity === "Error").map((e) => e.message);
+		if (errorMessages.length > 0) {
+			return code;
+		}
+	}
+	if (parser === "json") {
+		return formatted.code;
+	}
+	const tmpFile = join(process.cwd(), `.sonamu-fmt-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`);
+	try {
+		writeFileSync(tmpFile, formatted.code, "utf-8");
+		const oxlintBin = resolveOxlintBin();
+		try {
+			execFileSync(oxlintBin, [
+				"--fix",
+				"--fix-suggestions",
+				"--type-aware",
+				tmpFile
+			], {
+				stdio: "pipe",
+				timeout: 1e4
+			});
+		} catch (execError) {
+			if (execError instanceof Error) {
+				const errObj = execError;
+				if (typeof errObj.status === "number") {
+					void errObj.status;
+				} else {
+					throw execError;
+				}
+			} else {
+				throw execError;
+			}
+		}
+		const lintFixed = readFileSync(tmpFile, "utf-8");
+		const reformatted = await format(fileName, lintFixed, OXFMT_OPTIONS);
+		if (reformatted.errors.length > 0) {
+			const errorMessages = reformatted.errors.filter((e) => e.severity === "Error").map((e) => e.message);
+			if (errorMessages.length > 0) {
+				!isTest() && console.error("oxfmt reformat errors:", errorMessages);
+				throw new Error(`oxfmt reformat error: ${errorMessages.join(", ")}`);
+			}
+		}
+		return reformatted.code;
+	} finally {
+		try {
+			unlinkSync(tmpFile);
+		} catch {}
+	}
 }
+var _require, OXFMT_OPTIONS;
+var init_formatter = __esmMin((() => {
+	init_controller();
+	_require = createRequire(import.meta.url);
+	OXFMT_OPTIONS = {
+		printWidth: 100,
+		tabWidth: 2,
+		useTabs: false,
+		singleQuote: false,
+		jsxSingleQuote: false,
+		trailingComma: "all",
+		semi: true,
+		endOfLine: "lf",
+		bracketSpacing: true,
+		sortImports: true
+	};
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utils/formatter.ts"],"sourcesContent":["import { Biome } from \"@biomejs/js-api/nodejs\";\nimport { Naite } from \"../naite/naite\";\nimport { isTest } from \"./controller\";\n\nconst biome = new Biome();\nlet projectKey: number = -1;\n\nexport function setupBiome(path: string) {\n  if (projectKey !== -1) {\n    return;\n  }\n\n  projectKey = biome.openProject(path).projectKey;\n  biome.applyConfiguration(projectKey, {\n    formatter: {\n      enabled: true,\n      formatWithErrors: false,\n      indentStyle: \"space\",\n      indentWidth: 2,\n      lineEnding: \"lf\",\n      lineWidth: 100,\n      attributePosition: \"auto\",\n    },\n    linter: {\n      enabled: true,\n      rules: {\n        recommended: true,\n        style: {\n          useNodejsImportProtocol: \"off\",\n        },\n        correctness: {\n          useParseIntRadix: \"off\",\n          noEmptyPattern: \"off\",\n          noUnusedImports: {\n            level: \"warn\",\n            fix: \"safe\",\n          },\n        },\n        a11y: {\n          noLabelWithoutControl: \"off\",\n        },\n        complexity: {\n          noBannedTypes: \"off\",\n        },\n        suspicious: {\n          noArrayIndexKey: \"off\",\n        },\n      },\n    },\n    javascript: {\n      formatter: {\n        jsxQuoteStyle: \"double\",\n        quoteProperties: \"asNeeded\",\n        trailingCommas: \"all\",\n        semicolons: \"always\",\n        arrowParentheses: \"always\",\n        bracketSpacing: true,\n        bracketSameLine: false,\n        quoteStyle: \"double\",\n        attributePosition: \"auto\",\n      },\n    },\n    json: {\n      formatter: {\n        indentWidth: 2,\n      },\n    },\n    assist: {\n      enabled: true,\n      actions: {\n        source: {\n          organizeImports: \"on\",\n        },\n      },\n    },\n  });\n}\n\nexport function formatCode(code: string, parser: \"typescript\" | \"json\", filePath: string) {\n  Naite.t(\"formatCode\", { code, parser });\n\n  if (projectKey === -1) {\n    console.warn(\"Biome is not setup. Please call setupBiome first.\");\n    return code;\n  }\n\n  // 포맷팅을 먼저 해야함\n  const formatted = biome.formatContent(projectKey, code, { filePath });\n  Naite.t(\"formatCode:formatted\", formatted);\n  if (formatted.diagnostics.filter((d) => d.severity === \"error\").length > 0) {\n    console.error(formatted.diagnostics);\n    throw new Error(\"Biome format error\");\n  }\n\n  // 린팅을 그 다음에\n  const linted = biome.lintContent(projectKey, formatted.content, {\n    filePath,\n    fixFileMode: \"safeAndUnsafeFixes\",\n  });\n  if (linted.diagnostics.filter((d) => d.severity === \"error\").length > 0) {\n    Naite.t(\"formatCode:linted:content\", linted.content);\n    Naite.t(\"formatCode:linted:diagnostics\", linted.diagnostics);\n    !isTest() && console.dir(linted.diagnostics, { depth: null });\n    throw new Error(\"Biome lint error\");\n  }\n  Naite.t(\"formatCode:linted\", linted);\n\n  // 포맷팅 한 번 더 (import 구문에 type 키워드 추가되는 경우 maxWidth 초과로 인한 에러 발생)\n  const formattedAgain = biome.formatContent(projectKey, linted.content, { filePath });\n  if (formattedAgain.diagnostics.filter((d) => d.severity === \"error\").length > 0) {\n    console.error(formattedAgain.diagnostics);\n    throw new Error(\"Biome format error\");\n  }\n\n  return formattedAgain.content;\n}\n"],"names":["Biome","Naite","isTest","biome","projectKey","setupBiome","path","openProject","applyConfiguration","formatter","enabled","formatWithErrors","indentStyle","indentWidth","lineEnding","lineWidth","attributePosition","linter","rules","recommended","style","useNodejsImportProtocol","correctness","useParseIntRadix","noEmptyPattern","noUnusedImports","level","fix","a11y","noLabelWithoutControl","complexity","noBannedTypes","suspicious","noArrayIndexKey","javascript","jsxQuoteStyle","quoteProperties","trailingCommas","semicolons","arrowParentheses","bracketSpacing","bracketSameLine","quoteStyle","json","assist","actions","source","organizeImports","formatCode","code","parser","filePath","t","console","warn","formatted","formatContent","diagnostics","filter","d","severity","length","error","Error","linted","lintContent","content","fixFileMode","dir","depth","formattedAgain"],"mappings":"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"}
+//#endregion
+init_formatter();
+export { formatCode, init_formatter };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/fs-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs-utils.d.ts","sourceRoot":"","sources":["../../src/utils/fs-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,IAAI,CAAC;AAI9C;;;;;GAKG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAO7D;AAGD,wBAAsB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAOjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,+BAA+B,CACnD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,OAAO,CAAC,CAqClB"}
+{"version":3,"file":"fs-utils.d.ts","sourceRoot":"","sources":["../../src/utils/fs-utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,IAAI,CAAC;AAInC;;;;;GAKG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAO7D;AAGD,wBAAsB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAOjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,+BAA+B,CACnD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,OAAO,CAAC,CAqClB"}

package/dist/utils/fs-utils.js

@@ -1,72 +1,75 @@
-import { constants } from "fs";
-import { access, readFile, stat, writeFile } from "node:fs/promises";
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { access, readFile, stat, writeFile } from "fs/promises";
 import path, { dirname } from "path";
+import { constants } from "fs";
+
+//#region src/utils/fs-utils.ts
 /**
- * fs/promises에는 exists가 없어요. 대신 access가 있습니다.
- * 근데 얘는 인터페이스가 쓰기 불편해요. 그래서 감싸주었습니다.
- * @param path
- * @returns
- */ export async function exists(path) {
-    try {
-        await access(path, constants.F_OK);
-        return true;
-    } catch  {
-        return false;
-    }
+* fs/promises에는 exists가 없어요. 대신 access가 있습니다.
+* 근데 얘는 인터페이스가 쓰기 불편해요. 그래서 감싸주었습니다.
+* @param path
+* @returns
+*/
+async function exists(path$1) {
+	try {
+		await access(path$1, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
 }
-// 디렉토리가 아니라 파일만 존재하는지 확인합니다.
-export async function fileExists(path) {
-    try {
-        const stats = await stat(path);
-        return stats.isFile();
-    } catch  {
-        return false;
-    }
+async function fileExists(path$1) {
+	try {
+		const stats = await stat(path$1);
+		return stats.isFile();
+	} catch {
+		return false;
+	}
 }
 /**
- * 파일을 복사하면서 `from "sonamu"` import를 sonamu.shared.ts 경로로 치환합니다.
- *
- * web이나 app 등에는 sonamu 패키지가 없으므로, 함께 복사되는 sonamu.shared.ts에서 가져오도록 변환합니다.
- * 대상 파일의 위치에 따라 상대 경로가 달라집니다:
- * - services/sonamu.generated.ts → ./sonamu.shared
- * - services/user/user.types.ts → ../sonamu.shared
- * - i18n/ko.ts → ../services/sonamu.shared
- *
- * @param fromPath 원본 파일 경로
- * @param toPath 대상 파일 경로
- * @param syncHeader 동기화 시 파일 최상단에 삽입할 주석 블록. 기존 @generated 블록이 있으면 교체하고, 없으면 최상단에 추가합니다.
- * @returns 파일을 썼으면 true, 건너뛰었으면 false
- */ export async function copyFileWithReplaceCoreToShared(fromPath, toPath, syncHeader) {
-    if (!await exists(fromPath)) {
-        return false;
-    }
-    const oldFileContent = (await readFile(fromPath)).toString();
-    let newFileContent = (()=>{
-        // sonamu.shared.ts는 항상 {base}/src/services/sonamu.shared.ts에 위치합니다.
-        // toPath에서 /src/를 찾아 services 디렉토리 경로를 계산합니다.
-        const srcMatch = toPath.match(/^(.+\/src)\//);
-        if (!srcMatch) {
-            // /src/가 없으면 변환 없이 그대로 반환
-            return oldFileContent;
-        }
-        const servicesDir = path.join(srcMatch[1], "services");
-        const fileDir = dirname(toPath);
-        const relativePath = path.relative(fileDir, servicesDir);
-        const sharedPath = relativePath === "" ? "./sonamu.shared" : `${relativePath}/sonamu.shared`;
-        return oldFileContent.replace(/from "sonamu(\/dict)?"/g, `from "${sharedPath}"`);
-    })();
-    // syncHeader가 제공된 경우 @generated 블록을 교체하거나 최상단에 추가합니다.
-    if (syncHeader) {
-        // 여러 줄 형식만 매칭합니다. 한 줄짜리(/** @generated */)는 매칭하지 않으므로 수동으로 축약하지 마세요.
-        const generatedBlockRegex = /\/\*\*\r?\n \* @generated\r?\n[\s\S]*?\*\/\r?\n/;
-        if (generatedBlockRegex.test(newFileContent)) {
-            newFileContent = newFileContent.replace(generatedBlockRegex, `${syncHeader}\n`);
-        } else {
-            newFileContent = `${syncHeader}\n${newFileContent}`;
-        }
-    }
-    await writeFile(toPath, newFileContent);
-    return true;
+* 파일을 복사하면서 `from "sonamu"` import를 sonamu.shared.ts 경로로 치환합니다.
+*
+* web이나 app 등에는 sonamu 패키지가 없으므로, 함께 복사되는 sonamu.shared.ts에서 가져오도록 변환합니다.
+* 대상 파일의 위치에 따라 상대 경로가 달라집니다:
+* - services/sonamu.generated.ts → ./sonamu.shared
+* - services/user/user.types.ts → ../sonamu.shared
+* - i18n/ko.ts → ../services/sonamu.shared
+*
+* @param fromPath 원본 파일 경로
+* @param toPath 대상 파일 경로
+* @param syncHeader 동기화 시 파일 최상단에 삽입할 주석 블록. 기존 @generated 블록이 있으면 교체하고, 없으면 최상단에 추가합니다.
+* @returns 파일을 썼으면 true, 건너뛰었으면 false
+*/
+async function copyFileWithReplaceCoreToShared(fromPath, toPath, syncHeader) {
+	if (!await exists(fromPath)) {
+		return false;
+	}
+	const oldFileContent = (await readFile(fromPath)).toString();
+	let newFileContent = (() => {
+		const srcMatch = toPath.match(/^(.+\/src)\//);
+		if (!srcMatch) {
+			return oldFileContent;
+		}
+		const servicesDir = path.join(srcMatch[1], "services");
+		const fileDir = dirname(toPath);
+		const relativePath = path.relative(fileDir, servicesDir);
+		const sharedPath = relativePath === "" ? "./sonamu.shared" : `${relativePath}/sonamu.shared`;
+		return oldFileContent.replace(/from "sonamu(\/dict)?"/g, `from "${sharedPath}"`);
+	})();
+	if (syncHeader) {
+		const generatedBlockRegex = /\/\*\*\r?\n \* @generated\r?\n[\s\S]*?\*\/\r?\n/;
+		if (generatedBlockRegex.test(newFileContent)) {
+			newFileContent = newFileContent.replace(generatedBlockRegex, `${syncHeader}\n`);
+		} else {
+			newFileContent = `${syncHeader}\n${newFileContent}`;
+		}
+	}
+	await writeFile(toPath, newFileContent);
+	return true;
 }
+var init_fs_utils = __esmMin((() => {}));
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+init_fs_utils();
+export { copyFileWithReplaceCoreToShared, exists, fileExists, init_fs_utils };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/lodash-able.js

@@ -1,6 +1,13 @@
-export function wrapIf(source, predicate) {
-    const [ok, wrapped] = predicate(source);
-    return ok ? wrapped : source;
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+
+//#region src/utils/lodash-able.ts
+function wrapIf(source, predicate) {
+	const [ok, wrapped] = predicate(source);
+	return ok ? wrapped : source;
 }
+var init_lodash_able = __esmMin((() => {}));
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9sb2Rhc2gtYWJsZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gd3JhcElmKHNvdXJjZTogc3RyaW5nLCBwcmVkaWNhdGU6IChzdHI6IHN0cmluZykgPT4gW2Jvb2xlYW4sIHN0cmluZ10pOiBzdHJpbmcge1xuICBjb25zdCBbb2ssIHdyYXBwZWRdID0gcHJlZGljYXRlKHNvdXJjZSk7XG4gIHJldHVybiBvayA/IHdyYXBwZWQgOiBzb3VyY2U7XG59XG4iXSwibmFtZXMiOlsid3JhcElmIiwic291cmNlIiwicHJlZGljYXRlIiwib2siLCJ3cmFwcGVkIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFNBQVNBLE9BQU9DLE1BQWMsRUFBRUMsU0FBNkM7SUFDbEYsTUFBTSxDQUFDQyxJQUFJQyxRQUFRLEdBQUdGLFVBQVVEO0lBQ2hDLE9BQU9FLEtBQUtDLFVBQVVIO0FBQ3hCIn0=
+//#endregion
+init_lodash_able();
+export { init_lodash_able, wrapIf };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9kYXNoLWFibGUuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2xvZGFzaC1hYmxlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiB3cmFwSWYoc291cmNlOiBzdHJpbmcsIHByZWRpY2F0ZTogKHN0cjogc3RyaW5nKSA9PiBbYm9vbGVhbiwgc3RyaW5nXSk6IHN0cmluZyB7XG4gIGNvbnN0IFtvaywgd3JhcHBlZF0gPSBwcmVkaWNhdGUoc291cmNlKTtcbiAgcmV0dXJuIG9rID8gd3JhcHBlZCA6IHNvdXJjZTtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsU0FBZ0IsT0FBTyxRQUFnQixXQUF1RDtDQUM1RixNQUFNLENBQUMsSUFBSSxXQUFXLFVBQVUsT0FBTztBQUN2QyxRQUFPLEtBQUssVUFBVSJ9

package/dist/utils/model.d.ts

@@ -1,4 +1,4 @@
-import type { SonamuQueryMode } from "..";
+import { type SonamuQueryMode } from "../types/types";
 type WithSimilarity<LP, T> = LP extends {
     semanticQuery: Record<string, unknown>;
 } ? T & {

package/dist/utils/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/utils/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAG1C,KAAK,cAAc,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,SAAS;IAAE,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAC9E,CAAC,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAC1B,CAAC,CAAC;AAEN,MAAM,MAAM,UAAU,CACpB,EAAE,SAAS;IAAE,SAAS,CAAC,EAAE,eAAe,CAAA;CAAE,EAC1C,CAAC,IACC,EAAE,CAAC,WAAW,CAAC,SAAS,MAAM,GAC9B;IAAE,IAAI,EAAE,cAAc,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAA;CAAE,GACjC,EAAE,CAAC,WAAW,CAAC,SAAS,OAAO,GAC7B;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,cAAc,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;AAEjC,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAM9C;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAA;CAAE,mCAOlD;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/utils/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGtD,KAAK,cAAc,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,SAAS;IAAE,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAC9E,CAAC,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAC1B,CAAC,CAAC;AAEN,MAAM,MAAM,UAAU,CACpB,EAAE,SAAS;IAAE,SAAS,CAAC,EAAE,eAAe,CAAA;CAAE,EAC1C,CAAC,IACC,EAAE,CAAC,WAAW,CAAC,SAAS,MAAM,GAC9B;IAAE,IAAI,EAAE,cAAc,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAA;CAAE,GACjC,EAAE,CAAC,WAAW,CAAC,SAAS,OAAO,GAC7B;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,cAAc,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;AAEjC,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAM9C;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAA;CAAE,mCAOlD;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC"}

package/dist/utils/model.js

@@ -1,22 +1,24 @@
-export function asArray(param) {
-    if (Array.isArray(param)) {
-        return param;
-    } else {
-        return [
-            param
-        ];
-    }
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+
+//#region src/utils/model.ts
+function asArray(param) {
+	if (Array.isArray(param)) {
+		return param;
+	} else {
+		return [param];
+	}
 }
-export function objToMap(obj) {
-    const keys = Object.keys(obj);
-    if (keys.every((key)=>parseInt(key).toString() === key)) {
-        return new Map(keys.map((key)=>[
-                parseInt(key),
-                obj[key]
-            ]));
-    } else {
-        return new Map(Object.entries(obj));
-    }
+function objToMap(obj) {
+	const keys = Object.keys(obj);
+	if (keys.every((key) => parseInt(key).toString() === key)) {
+		return new Map(keys.map((key) => [parseInt(key), obj[key]]));
+	} else {
+		return new Map(Object.entries(obj));
+	}
 }
+var init_model = __esmMin((() => {}));
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+init_model();
+export { asArray, init_model, objToMap };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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