@cmmd-center/forge 0.13.6 → 0.13.8

package/dist/node_modules/ffi-rs/index.d.ts

@@ -0,0 +1,222 @@
+
+interface RawPointer { }
+
+export interface JsExternal {
+  _externalDataPlaceholder: RawPointer;
+}
+
+export enum DataType {
+  /**
+   UTF-16 String, equivalent to char*
+  */
+  String = 0,
+  /**
+   UTF-16 String, equivalent to wchar*
+  */
+  WString = 15,
+  I32 = 1,
+  Double = 2,
+  /**
+    * denotes ordinary i32 number array instead of Uint32Array
+  */
+  I32Array = 3,
+  StringArray = 4,
+  /**
+    denotes f64 array
+  */
+  DoubleArray = 5,
+  Boolean = 6,
+  /**
+    equal with undefined
+  */
+  Void = 7,
+  I64 = 8,
+  U8 = 9,
+  /**
+    Equivanlent to Buffer
+  */
+  U8Array = 10,
+  /**
+    A type that wrap native pointer
+  */
+  External = 11,
+  U64 = 12,
+  FloatArray = 13,
+  Float = 14,
+  /**
+   As params will be transformed to i64, as return value will be created from i64
+  */
+  BigInt = 16,
+  I16 = 17,
+  StructArray = 18,
+  I16Array = 19,
+  U32 = 20,
+  StackStruct = 999, // reserve keyword
+  StackArray = 996,
+  Function = 998,
+  Array = 997,
+}
+
+type DataTypeToType<T> = T extends DataType.String
+  ? string
+  : T extends DataType.WString
+  ? string
+  : T extends DataType.U8
+  ? number
+  : T extends DataType.I32
+  ? number
+  : T extends DataType.I64
+  ? number
+  : T extends DataType.BigInt
+  ? BigInt
+  : T extends DataType.U64
+  ? number
+  : T extends DataType.U32
+  ? number
+  : T extends DataType.Double
+  ? number
+  : T extends DataType.External
+  ? JsExternal
+  : T extends DataType.U8Array
+  ? number[]
+  : T extends DataType.I16Array
+  ? number[]
+  : T extends DataType.I32Array
+  ? number[]
+  : T extends DataType.StringArray
+  ? string[]
+  : T extends DataType.DoubleArray
+  ? number[]
+  : T extends DataType.FloatArray
+  ? number[]
+  : T extends DataType.Boolean
+  ? boolean
+  : T extends DataType.Void
+  ? undefined
+  : never;
+
+export enum FFITypeTag {
+  StackStruct = DataType.StackStruct,
+  StackArray = DataType.StackArray,
+}
+
+export interface ArrayConstructorOptions {
+  type: DataType;
+  length: number;
+  ffiTypeTag?: FFITypeTag;
+  dynamicArray?: boolean
+  structItemType?: RecordFieldType
+}
+
+export interface FuncConstructorOptions {
+  paramsType: FieldType[];
+  retType: FieldType;
+  needFree?: boolean
+  // Default:false, whether or not free function call params memory automatically which are allocated in c side
+  freeCFuncParamsMemory?: boolean
+}
+
+export function arrayConstructor(options: ArrayConstructorOptions): ArrayConstructorOptions;
+
+export function funcConstructor(options: FuncConstructorOptions): FuncConstructorOptions;
+
+export interface OpenParams {
+  library: string;
+  path: string;
+}
+
+export function open(params: OpenParams): void;
+export function close(library: string): void;
+
+export function createPointer(params: {
+  paramsType: FieldType[];
+  paramsValue: unknown[];
+}): JsExternal[]
+
+export enum PointerType {
+  RsPointer = 0,
+  CPointer = 1
+}
+
+export function freePointer(params: {
+  paramsType: FieldType[];
+  paramsValue: JsExternal[];
+  pointerType: PointerType
+}): void
+
+export function restorePointer<T>(params: {
+  retType: FieldType[];
+  paramsValue: JsExternal[];
+}): DataTypeToType<T>[]
+
+export function unwrapPointer(params: JsExternal[]): JsExternal[]
+
+export function wrapPointer(params: JsExternal[]): JsExternal[]
+
+export function isNullPointer(params: JsExternal): boolean
+
+/**
+ * Wrap an existing native pointer into a Node.js `Buffer` **without copying**.
+ *
+ * The returned Buffer shares the same memory as `external`, so reads/writes on
+ * either side are immediately visible on the other — the zero-copy equivalent
+ * of ffi-napi's `ref.reinterpret`.
+ *
+ * `external` is the pointer to wrap (a `DataType.External` returned from `load`,
+ * or any `JsExternal` from `createPointer`/`unwrapPointer`/`wrapPointer`).
+ * `length` is the number of bytes to expose.
+ *
+ * ffi-rs does NOT free the underlying memory when the Buffer is garbage
+ * collected; the caller owns the pointer's lifetime (e.g. a region returned by
+ * `mmap` must stay mapped until you are done with the Buffer and call `munmap`
+ * yourself). On runtimes that forbid external buffers (e.g. Electron) this
+ * silently falls back to copying the data.
+ */
+export function createExternalBuffer(external: JsExternal, length: number): Buffer
+
+type ResultWithErrno<T, E = undefined> = E extends true
+  ? { value: T; errnoCode: number; errnoMessage: string }
+  : T;
+
+type ResultWithPromise<T, P = undefined> = P extends true
+  ? Promise<T>
+  : T;
+
+export type FieldType =
+  | DataType
+  | ArrayConstructorOptions
+  | FuncConstructorOptions
+  | RecordFieldType
+
+interface RecordFieldType extends Record<string, FieldType> { }
+
+type FieldTypeToType<T> = T extends DataType
+  ? DataTypeToType<T>
+  : T extends ArrayConstructorOptions
+  ? DataTypeToType<T['type']>
+  : T extends RecordFieldType
+  ? { [K in keyof T]: FieldTypeToType<T[K]> }
+  : never;
+
+export interface FFIParams<T, E = undefined, R = undefined> {
+  library: string;
+  funcName: string;
+  retType: T;
+  paramsType: FieldType[];
+  paramsValue: unknown[];
+  // whether need output errno
+  errno?: E
+  runInNewThread?: R
+  // Default:false, whether or not need to free the result of return value memory automatically
+  freeResultMemory?: boolean
+}
+
+export function load<T extends FieldType, E = undefined, R extends boolean | undefined = undefined>(
+  params: FFIParams<T, E, R>
+): R extends true ? Promise<ResultWithErrno<FieldTypeToType<T>, E>> : ResultWithErrno<FieldTypeToType<T>, E>
+
+type FuncObj<T, E = undefined, R = undefined> = Record<string, Omit<FFIParams<T, E, R>, 'paramsValue' | 'funcName'>>
+
+export function define<T extends FuncObj<FieldType, boolean | undefined, boolean | undefined>>(funcs: T): {
+  [K in keyof T]: (paramsValue: unknown[]) => ResultWithPromise<ResultWithErrno<FieldTypeToType<T[K]['retType']>, T[K]['errno']>, T[K]['runInNewThread']>;
+}

package/dist/node_modules/ffi-rs/index.js

@@ -0,0 +1,380 @@
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'ffi-rs.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./ffi-rs.android-arm64.node')
+          } else {
+            nativeBinding = require('@yuuang/ffi-rs-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'ffi-rs.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./ffi-rs.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@yuuang/ffi-rs-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'ffi-rs.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./ffi-rs.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@yuuang/ffi-rs-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'ffi-rs.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./ffi-rs.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@yuuang/ffi-rs-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'ffi-rs.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./ffi-rs.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@yuuang/ffi-rs-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'ffi-rs.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./ffi-rs.darwin-universal.node')
+      } else {
+        nativeBinding = require('@yuuang/ffi-rs-darwin-universal')
+      }
+      break
+    } catch { }
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'ffi-rs.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./ffi-rs.darwin-x64.node')
+          } else {
+            nativeBinding = require('@yuuang/ffi-rs-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'ffi-rs.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./ffi-rs.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@yuuang/ffi-rs-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'ffi-rs.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./ffi-rs.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@yuuang/ffi-rs-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'ffi-rs.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./ffi-rs.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@yuuang/ffi-rs-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'ffi-rs.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./ffi-rs.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@yuuang/ffi-rs-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'ffi-rs.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./ffi-rs.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@yuuang/ffi-rs-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'ffi-rs.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./ffi-rs.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@yuuang/ffi-rs-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'ffi-rs.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./ffi-rs.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@yuuang/ffi-rs-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'ffi-rs.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./ffi-rs.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@yuuang/ffi-rs-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'ffi-rs.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./ffi-rs.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@yuuang/ffi-rs-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'ffi-rs.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./ffi-rs.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@yuuang/ffi-rs-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'ffi-rs.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./ffi-rs.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@yuuang/ffi-rs-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+    (processParamsTypeForArray(params))
+}
+
+const { DataType, createPointer, restorePointer, unwrapPointer, wrapPointer, freePointer, open, close, load, isNullPointer, FFITypeTag, createExternalBuffer } = nativeBinding
+DataType.StackStruct = 999
+DataType.Function = 998
+DataType.Array = 997
+DataType.StackArray = 996
+exports.DataType = DataType
+exports.PointerType = nativeBinding.PointerType
+exports.open = open
+exports.close = close
+exports.load = load
+exports.isNullPointer = isNullPointer
+exports.FFITypeTag = FFITypeTag
+const arrayDataType = [DataType.I16Array, DataType.I32Array, DataType.StringArray, DataType.DoubleArray, DataType.U8Array, DataType.FloatArray]
+const arrayConstructor = (options) => ({
+  ffiTypeTag: FFITypeTag.Array,
+  ...options
+})
+
+const processParamsTypeForArray = (params) => {
+  params.paramsType = params.paramsType?.map((paramType, index) => {
+    if (arrayDataType.includes(paramType)) {
+      return arrayConstructor({
+        type: paramType,
+        length: params.paramsValue[index].length,
+      })
+    }
+    return paramType
+  })
+  return params
+}
+
+const setFreePointerTag = (params) => {
+  params.paramsType = params.paramsType?.map((paramType, index) => {
+    if (paramType.ffiTypeTag === FFITypeTag.Function) {
+      paramType.needFree = true
+    }
+    return paramType
+  })
+  return params
+}
+
+const wrapLoad = (params) => {
+  if (params.freeResultMemory === undefined) {
+    params.freeResultMemory = false
+  }
+  return load(processParamsTypeForArray(params))
+}
+exports.load = wrapLoad
+exports.createPointer = (params) => createPointer(processParamsTypeForArray(params))
+exports.restorePointer = (params) => restorePointer(processParamsTypeForArray(params))
+exports.unwrapPointer = (params) => unwrapPointer(processParamsTypeForArray(params))
+exports.wrapPointer = (params) => wrapPointer(processParamsTypeForArray(params))
+exports.freePointer = (params) => freePointer(setFreePointerTag(processParamsTypeForArray(params)))
+exports.createExternalBuffer = createExternalBuffer
+exports.arrayConstructor = arrayConstructor
+
+exports.funcConstructor = (options) => ({
+  ffiTypeTag: FFITypeTag.Function,
+  needFree: false,
+  freeCFuncParamsMemory: false,
+  ...options,
+})
+exports.define = (obj) => {
+  const res = {}
+  Object.entries(obj).map(([funcName, funcDesc]) => {
+    res[funcName] = (paramsValue = []) => wrapLoad({
+      ...funcDesc,
+      funcName,
+      paramsValue
+    })
+  })
+  return res
+}

package/dist/node_modules/ffi-rs/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "ffi-rs",
+  "version": "1.3.7",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "description": "A module written in Rust and N-API provides interface (FFI) features for Node.js",
+  "napi": {
+    "name": "ffi-rs",
+    "triples": {
+      "additional": [
+        "aarch64-apple-darwin",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "arm-unknown-linux-gnueabihf",
+        "i686-pc-windows-msvc",
+        "x86_64-unknown-linux-musl",
+        "aarch64-pc-windows-msvc",
+        "aarch64-linux-android"
+      ]
+    }
+  },
+  "author": "zhangyuang",
+  "homepage": "https://github.com/zhangyuang/node-ffi-rs#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhangyuang/node-ffi-rs.git"
+  },
+  "keywords": [
+    "ffi",
+    "rust",
+    "node.js",
+    "napi"
+  ],
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ],
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+    "@napi-rs/cli": "^2.15.2",
+    "@types/node": "^20.8.7",
+    "benny": "^3.7.1",
+    "conventional-changelog-cli": "^4.1.0",
+    "esno": "^4.0.0",
+    "koa": "^2.14.2",
+    "shelljs": "^0.8.5",
+    "typescript": "^5.4.5"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build:c": "node scripts/compile.js",
+    "build:dev": "env=development node scripts/build.js",
+    "build": "node scripts/build.js",
+    "publish:npm": "node scripts/publish.js",
+    "test": "esno ./tests/index.ts",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0 && git add . && git commit -m \"docs: update changelog.md\" && git push origin master",
+    "pub": "npm version patch && git push origin master --tags && npm run changelog",
+    "copy": "cp -r ./tests ./*.md ./package.json ../node-ffi-rs/",
+    "pub:alpha": "npm version prerelease --preid=alpha && git push origin master --tags"
+  },
+  "optionalDependencies": {
+    "@yuuang/ffi-rs-android-arm64": "1.3.7",
+    "@yuuang/ffi-rs-darwin-arm64": "1.3.7",
+    "@yuuang/ffi-rs-darwin-x64": "1.3.7",
+    "@yuuang/ffi-rs-linux-arm-gnueabihf": "1.3.7",
+    "@yuuang/ffi-rs-linux-arm64-gnu": "1.3.7",
+    "@yuuang/ffi-rs-linux-arm64-musl": "1.3.7",
+    "@yuuang/ffi-rs-linux-x64-gnu": "1.3.7",
+    "@yuuang/ffi-rs-linux-x64-musl": "1.3.7",
+    "@yuuang/ffi-rs-win32-arm64-msvc": "1.3.7",
+    "@yuuang/ffi-rs-win32-ia32-msvc": "1.3.7",
+    "@yuuang/ffi-rs-win32-x64-msvc": "1.3.7"
+  }
+}

package/dist/{open-FIgTDosf.mjs → open-D8mGyWmt.mjs}

@@ -2,7 +2,7 @@
 
 import childProcess, { execFile } from "node:child_process";
 import fs from "node:fs";
-import os from "node:os";
+import $U from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import process from "node:process";
@@ -49,7 +49,7 @@ function isInsideContainer() {
 //#region ../../node_modules/.bun/is-wsl@3.1.1/node_modules/is-wsl/index.js
 const isWsl = () => {
 	if (process.platform !== "linux") return false;
-	if (os.release().toLowerCase().includes("microsoft")) {
+	if ($U.release().toLowerCase().includes("microsoft")) {
 		if (isInsideContainer()) return false;
 		return true;
 	}
@@ -589,4 +589,4 @@ defineLazyProperty(apps, "safari", () => detectPlatformBinary({ darwin: "Safari"
 //#endregion
 export { apps, open as default, openApp };
 
-//# sourceMappingURL=open-FIgTDosf.mjs.map
+//# sourceMappingURL=open-D8mGyWmt.mjs.map