@weavelogic/knowledge-graph-agent 0.6.0 → 0.7.1

package/dist/node_modules/onnxruntime-common/dist/lib/inference-session-impl.js

@@ -0,0 +1,162 @@
+import { resolveBackend } from "./backend-impl.js";
+import { Tensor } from "./tensor.js";
+class InferenceSession {
+  constructor(handler) {
+    this.handler = handler;
+  }
+  async run(feeds, arg1, arg2) {
+    const fetches = {};
+    let options = {};
+    if (typeof feeds !== "object" || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {
+      throw new TypeError("'feeds' must be an object that use input names as keys and OnnxValue as corresponding values.");
+    }
+    let isFetchesEmpty = true;
+    if (typeof arg1 === "object") {
+      if (arg1 === null) {
+        throw new TypeError("Unexpected argument[1]: cannot be null.");
+      }
+      if (arg1 instanceof Tensor) {
+        throw new TypeError("'fetches' cannot be a Tensor");
+      }
+      if (Array.isArray(arg1)) {
+        if (arg1.length === 0) {
+          throw new TypeError("'fetches' cannot be an empty array.");
+        }
+        isFetchesEmpty = false;
+        for (const name of arg1) {
+          if (typeof name !== "string") {
+            throw new TypeError("'fetches' must be a string array or an object.");
+          }
+          if (this.outputNames.indexOf(name) === -1) {
+            throw new RangeError(`'fetches' contains invalid output name: ${name}.`);
+          }
+          fetches[name] = null;
+        }
+        if (typeof arg2 === "object" && arg2 !== null) {
+          options = arg2;
+        } else if (typeof arg2 !== "undefined") {
+          throw new TypeError("'options' must be an object.");
+        }
+      } else {
+        let isFetches = false;
+        const arg1Keys = Object.getOwnPropertyNames(arg1);
+        for (const name of this.outputNames) {
+          if (arg1Keys.indexOf(name) !== -1) {
+            const v = arg1[name];
+            if (v === null || v instanceof Tensor) {
+              isFetches = true;
+              isFetchesEmpty = false;
+              fetches[name] = v;
+            }
+          }
+        }
+        if (isFetches) {
+          if (typeof arg2 === "object" && arg2 !== null) {
+            options = arg2;
+          } else if (typeof arg2 !== "undefined") {
+            throw new TypeError("'options' must be an object.");
+          }
+        } else {
+          options = arg1;
+        }
+      }
+    } else if (typeof arg1 !== "undefined") {
+      throw new TypeError("Unexpected argument[1]: must be 'fetches' or 'options'.");
+    }
+    for (const name of this.inputNames) {
+      if (typeof feeds[name] === "undefined") {
+        throw new Error(`input '${name}' is missing in 'feeds'.`);
+      }
+    }
+    if (isFetchesEmpty) {
+      for (const name of this.outputNames) {
+        fetches[name] = null;
+      }
+    }
+    const results = await this.handler.run(feeds, fetches, options);
+    const returnValue = {};
+    for (const key in results) {
+      if (Object.hasOwnProperty.call(results, key)) {
+        returnValue[key] = new Tensor(results[key].type, results[key].data, results[key].dims);
+      }
+    }
+    return returnValue;
+  }
+  static async create(arg0, arg1, arg2, arg3) {
+    let filePathOrUint8Array;
+    let options = {};
+    if (typeof arg0 === "string") {
+      filePathOrUint8Array = arg0;
+      if (typeof arg1 === "object" && arg1 !== null) {
+        options = arg1;
+      } else if (typeof arg1 !== "undefined") {
+        throw new TypeError("'options' must be an object.");
+      }
+    } else if (arg0 instanceof Uint8Array) {
+      filePathOrUint8Array = arg0;
+      if (typeof arg1 === "object" && arg1 !== null) {
+        options = arg1;
+      } else if (typeof arg1 !== "undefined") {
+        throw new TypeError("'options' must be an object.");
+      }
+    } else if (arg0 instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && arg0 instanceof SharedArrayBuffer) {
+      const buffer = arg0;
+      let byteOffset = 0;
+      let byteLength = arg0.byteLength;
+      if (typeof arg1 === "object" && arg1 !== null) {
+        options = arg1;
+      } else if (typeof arg1 === "number") {
+        byteOffset = arg1;
+        if (!Number.isSafeInteger(byteOffset)) {
+          throw new RangeError("'byteOffset' must be an integer.");
+        }
+        if (byteOffset < 0 || byteOffset >= buffer.byteLength) {
+          throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);
+        }
+        byteLength = arg0.byteLength - byteOffset;
+        if (typeof arg2 === "number") {
+          byteLength = arg2;
+          if (!Number.isSafeInteger(byteLength)) {
+            throw new RangeError("'byteLength' must be an integer.");
+          }
+          if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {
+            throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);
+          }
+          if (typeof arg3 === "object" && arg3 !== null) {
+            options = arg3;
+          } else if (typeof arg3 !== "undefined") {
+            throw new TypeError("'options' must be an object.");
+          }
+        } else if (typeof arg2 !== "undefined") {
+          throw new TypeError("'byteLength' must be a number.");
+        }
+      } else if (typeof arg1 !== "undefined") {
+        throw new TypeError("'options' must be an object.");
+      }
+      filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);
+    } else {
+      throw new TypeError("Unexpected argument[0]: must be 'path' or 'buffer'.");
+    }
+    const eps = options.executionProviders || [];
+    const backendHints = eps.map((i) => typeof i === "string" ? i : i.name);
+    const backend = await resolveBackend(backendHints);
+    const handler = await backend.createSessionHandler(filePathOrUint8Array, options);
+    return new InferenceSession(handler);
+  }
+  startProfiling() {
+    this.handler.startProfiling();
+  }
+  endProfiling() {
+    this.handler.endProfiling();
+  }
+  get inputNames() {
+    return this.handler.inputNames;
+  }
+  get outputNames() {
+    return this.handler.outputNames;
+  }
+}
+export {
+  InferenceSession
+};
+//# sourceMappingURL=inference-session-impl.js.map

package/dist/node_modules/onnxruntime-common/dist/lib/inference-session-impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference-session-impl.js","sources":["../../../../../node_modules/onnxruntime-common/dist/lib/inference-session-impl.js"],"sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\nimport { resolveBackend } from './backend-impl';\nimport { Tensor } from './tensor';\nexport class InferenceSession {\n    constructor(handler) {\n        this.handler = handler;\n    }\n    async run(feeds, arg1, arg2) {\n        const fetches = {};\n        let options = {};\n        // check inputs\n        if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {\n            throw new TypeError('\\'feeds\\' must be an object that use input names as keys and OnnxValue as corresponding values.');\n        }\n        let isFetchesEmpty = true;\n        // determine which override is being used\n        if (typeof arg1 === 'object') {\n            if (arg1 === null) {\n                throw new TypeError('Unexpected argument[1]: cannot be null.');\n            }\n            if (arg1 instanceof Tensor) {\n                throw new TypeError('\\'fetches\\' cannot be a Tensor');\n            }\n            if (Array.isArray(arg1)) {\n                if (arg1.length === 0) {\n                    throw new TypeError('\\'fetches\\' cannot be an empty array.');\n                }\n                isFetchesEmpty = false;\n                // output names\n                for (const name of arg1) {\n                    if (typeof name !== 'string') {\n                        throw new TypeError('\\'fetches\\' must be a string array or an object.');\n                    }\n                    if (this.outputNames.indexOf(name) === -1) {\n                        throw new RangeError(`'fetches' contains invalid output name: ${name}.`);\n                    }\n                    fetches[name] = null;\n                }\n                if (typeof arg2 === 'object' && arg2 !== null) {\n                    options = arg2;\n                }\n                else if (typeof arg2 !== 'undefined') {\n                    throw new TypeError('\\'options\\' must be an object.');\n                }\n            }\n            else {\n                // decide whether arg1 is fetches or options\n                // if any output name is present and its value is valid OnnxValue, we consider it fetches\n                let isFetches = false;\n                const arg1Keys = Object.getOwnPropertyNames(arg1);\n                for (const name of this.outputNames) {\n                    if (arg1Keys.indexOf(name) !== -1) {\n                        const v = arg1[name];\n                        if (v === null || v instanceof Tensor) {\n                            isFetches = true;\n                            isFetchesEmpty = false;\n                            fetches[name] = v;\n                        }\n                    }\n                }\n                if (isFetches) {\n                    if (typeof arg2 === 'object' && arg2 !== null) {\n                        options = arg2;\n                    }\n                    else if (typeof arg2 !== 'undefined') {\n                        throw new TypeError('\\'options\\' must be an object.');\n                    }\n                }\n                else {\n                    options = arg1;\n                }\n            }\n        }\n        else if (typeof arg1 !== 'undefined') {\n            throw new TypeError('Unexpected argument[1]: must be \\'fetches\\' or \\'options\\'.');\n        }\n        // check if all inputs are in feed\n        for (const name of this.inputNames) {\n            if (typeof feeds[name] === 'undefined') {\n                throw new Error(`input '${name}' is missing in 'feeds'.`);\n            }\n        }\n        // if no fetches is specified, we use the full output names list\n        if (isFetchesEmpty) {\n            for (const name of this.outputNames) {\n                fetches[name] = null;\n            }\n        }\n        // feeds, fetches and options are prepared\n        const results = await this.handler.run(feeds, fetches, options);\n        const returnValue = {};\n        for (const key in results) {\n            if (Object.hasOwnProperty.call(results, key)) {\n                returnValue[key] = new Tensor(results[key].type, results[key].data, results[key].dims);\n            }\n        }\n        return returnValue;\n    }\n    static async create(arg0, arg1, arg2, arg3) {\n        // either load from a file or buffer\n        let filePathOrUint8Array;\n        let options = {};\n        if (typeof arg0 === 'string') {\n            filePathOrUint8Array = arg0;\n            if (typeof arg1 === 'object' && arg1 !== null) {\n                options = arg1;\n            }\n            else if (typeof arg1 !== 'undefined') {\n                throw new TypeError('\\'options\\' must be an object.');\n            }\n        }\n        else if (arg0 instanceof Uint8Array) {\n            filePathOrUint8Array = arg0;\n            if (typeof arg1 === 'object' && arg1 !== null) {\n                options = arg1;\n            }\n            else if (typeof arg1 !== 'undefined') {\n                throw new TypeError('\\'options\\' must be an object.');\n            }\n        }\n        else if (arg0 instanceof ArrayBuffer ||\n            (typeof SharedArrayBuffer !== 'undefined' && arg0 instanceof SharedArrayBuffer)) {\n            const buffer = arg0;\n            let byteOffset = 0;\n            let byteLength = arg0.byteLength;\n            if (typeof arg1 === 'object' && arg1 !== null) {\n                options = arg1;\n            }\n            else if (typeof arg1 === 'number') {\n                byteOffset = arg1;\n                if (!Number.isSafeInteger(byteOffset)) {\n                    throw new RangeError('\\'byteOffset\\' must be an integer.');\n                }\n                if (byteOffset < 0 || byteOffset >= buffer.byteLength) {\n                    throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);\n                }\n                byteLength = arg0.byteLength - byteOffset;\n                if (typeof arg2 === 'number') {\n                    byteLength = arg2;\n                    if (!Number.isSafeInteger(byteLength)) {\n                        throw new RangeError('\\'byteLength\\' must be an integer.');\n                    }\n                    if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {\n                        throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);\n                    }\n                    if (typeof arg3 === 'object' && arg3 !== null) {\n                        options = arg3;\n                    }\n                    else if (typeof arg3 !== 'undefined') {\n                        throw new TypeError('\\'options\\' must be an object.');\n                    }\n                }\n                else if (typeof arg2 !== 'undefined') {\n                    throw new TypeError('\\'byteLength\\' must be a number.');\n                }\n            }\n            else if (typeof arg1 !== 'undefined') {\n                throw new TypeError('\\'options\\' must be an object.');\n            }\n            filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);\n        }\n        else {\n            throw new TypeError('Unexpected argument[0]: must be \\'path\\' or \\'buffer\\'.');\n        }\n        // get backend hints\n        const eps = options.executionProviders || [];\n        const backendHints = eps.map(i => typeof i === 'string' ? i : i.name);\n        const backend = await resolveBackend(backendHints);\n        const handler = await backend.createSessionHandler(filePathOrUint8Array, options);\n        return new InferenceSession(handler);\n    }\n    startProfiling() {\n        this.handler.startProfiling();\n    }\n    endProfiling() {\n        this.handler.endProfiling();\n    }\n    get inputNames() {\n        return this.handler.inputNames;\n    }\n    get outputNames() {\n        return this.handler.outputNames;\n    }\n}\n//# sourceMappingURL=inference-session-impl.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/onnxruntime-common/dist/lib/inference-session.js

@@ -0,0 +1,6 @@
+import { InferenceSession as InferenceSession$1 } from "./inference-session-impl.js";
+const InferenceSession = InferenceSession$1;
+export {
+  InferenceSession
+};
+//# sourceMappingURL=inference-session.js.map

package/dist/node_modules/onnxruntime-common/dist/lib/inference-session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference-session.js","sources":["../../../../../node_modules/onnxruntime-common/dist/lib/inference-session.js"],"sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\nimport { InferenceSession as InferenceSessionImpl } from './inference-session-impl';\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const InferenceSession = InferenceSessionImpl;\n//# sourceMappingURL=inference-session.js.map"],"names":["InferenceSessionImpl"],"mappings":";AAIY,MAAC,mBAAmBA;","x_google_ignoreList":[0]}

package/dist/node_modules/onnxruntime-common/dist/lib/tensor-impl.js

@@ -0,0 +1,393 @@
+const isBigInt64ArrayAvailable = typeof BigInt64Array !== "undefined" && typeof BigInt64Array.from === "function";
+const isBigUint64ArrayAvailable = typeof BigUint64Array !== "undefined" && typeof BigUint64Array.from === "function";
+const NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = /* @__PURE__ */ new Map([
+  ["float32", Float32Array],
+  ["uint8", Uint8Array],
+  ["int8", Int8Array],
+  ["uint16", Uint16Array],
+  ["int16", Int16Array],
+  ["int32", Int32Array],
+  ["bool", Uint8Array],
+  ["float64", Float64Array],
+  ["uint32", Uint32Array]
+]);
+const NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = /* @__PURE__ */ new Map([
+  [Float32Array, "float32"],
+  [Uint8Array, "uint8"],
+  [Int8Array, "int8"],
+  [Uint16Array, "uint16"],
+  [Int16Array, "int16"],
+  [Int32Array, "int32"],
+  [Float64Array, "float64"],
+  [Uint32Array, "uint32"]
+]);
+if (isBigInt64ArrayAvailable) {
+  NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("int64", BigInt64Array);
+  NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, "int64");
+}
+if (isBigUint64ArrayAvailable) {
+  NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("uint64", BigUint64Array);
+  NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, "uint64");
+}
+const calculateSize = (dims) => {
+  let size = 1;
+  for (let i = 0; i < dims.length; i++) {
+    const dim = dims[i];
+    if (typeof dim !== "number" || !Number.isSafeInteger(dim)) {
+      throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);
+    }
+    if (dim < 0) {
+      throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);
+    }
+    size *= dim;
+  }
+  return size;
+};
+class Tensor {
+  constructor(arg0, arg1, arg2) {
+    let type;
+    let data;
+    let dims;
+    if (typeof arg0 === "string") {
+      type = arg0;
+      dims = arg2;
+      if (arg0 === "string") {
+        if (!Array.isArray(arg1)) {
+          throw new TypeError("A string tensor's data must be a string array.");
+        }
+        data = arg1;
+      } else {
+        const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);
+        if (typedArrayConstructor === void 0) {
+          throw new TypeError(`Unsupported tensor type: ${arg0}.`);
+        }
+        if (Array.isArray(arg1)) {
+          data = typedArrayConstructor.from(arg1);
+        } else if (arg1 instanceof typedArrayConstructor) {
+          data = arg1;
+        } else {
+          throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);
+        }
+      }
+    } else {
+      dims = arg1;
+      if (Array.isArray(arg0)) {
+        if (arg0.length === 0) {
+          throw new TypeError("Tensor type cannot be inferred from an empty array.");
+        }
+        const firstElementType = typeof arg0[0];
+        if (firstElementType === "string") {
+          type = "string";
+          data = arg0;
+        } else if (firstElementType === "boolean") {
+          type = "bool";
+          data = Uint8Array.from(arg0);
+        } else {
+          throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);
+        }
+      } else {
+        const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor);
+        if (mappedType === void 0) {
+          throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);
+        }
+        type = mappedType;
+        data = arg0;
+      }
+    }
+    if (dims === void 0) {
+      dims = [data.length];
+    } else if (!Array.isArray(dims)) {
+      throw new TypeError("A tensor's dims must be a number array");
+    }
+    const size = calculateSize(dims);
+    if (size !== data.length) {
+      throw new Error(`Tensor's size(${size}) does not match data length(${data.length}).`);
+    }
+    this.dims = dims;
+    this.type = type;
+    this.data = data;
+    this.size = size;
+  }
+  // #endregion
+  /**
+   * Create a new tensor object from image object
+   *
+   * @param buffer - Extracted image buffer data - assuming RGBA format
+   * @param imageFormat - input image configuration - required configurations height, width, format
+   * @param tensorFormat - output tensor configuration - Default is RGB format
+   */
+  static bufferToTensor(buffer, options) {
+    if (buffer === void 0) {
+      throw new Error("Image buffer must be defined");
+    }
+    if (options.height === void 0 || options.width === void 0) {
+      throw new Error("Image height and width must be defined");
+    }
+    const { height, width } = options;
+    const norm = options.norm;
+    let normMean;
+    let normBias;
+    if (norm === void 0 || norm.mean === void 0) {
+      normMean = 255;
+    } else {
+      normMean = norm.mean;
+    }
+    if (norm === void 0 || norm.bias === void 0) {
+      normBias = 0;
+    } else {
+      normBias = norm.bias;
+    }
+    const inputformat = options.bitmapFormat !== void 0 ? options.bitmapFormat : "RGBA";
+    const outputformat = options.tensorFormat !== void 0 ? options.tensorFormat !== void 0 ? options.tensorFormat : "RGB" : "RGB";
+    const offset = height * width;
+    const float32Data = outputformat === "RGBA" ? new Float32Array(offset * 4) : new Float32Array(offset * 3);
+    let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
+    let rTensorPointer = 0, gTensorPointer = offset, bTensorPointer = offset * 2, aTensorPointer = -1;
+    if (inputformat === "RGB") {
+      step = 3;
+      rImagePointer = 0;
+      gImagePointer = 1;
+      bImagePointer = 2;
+      aImagePointer = -1;
+    }
+    if (outputformat === "RGBA") {
+      aTensorPointer = offset * 3;
+    } else if (outputformat === "RBG") {
+      rTensorPointer = 0;
+      bTensorPointer = offset;
+      gTensorPointer = offset * 2;
+    } else if (outputformat === "BGR") {
+      bTensorPointer = 0;
+      gTensorPointer = offset;
+      rTensorPointer = offset * 2;
+    }
+    for (let i = 0; i < offset; i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {
+      float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias) / normMean;
+      float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias) / normMean;
+      float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias) / normMean;
+      if (aTensorPointer !== -1 && aImagePointer !== -1) {
+        float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias) / normMean;
+      }
+    }
+    const outputTensor = outputformat === "RGBA" ? new Tensor("float32", float32Data, [1, 4, height, width]) : new Tensor("float32", float32Data, [1, 3, height, width]);
+    return outputTensor;
+  }
+  static async fromImage(image, options) {
+    const isHTMLImageEle = typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement;
+    const isImageDataEle = typeof ImageData !== "undefined" && image instanceof ImageData;
+    const isImageBitmap = typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap;
+    const isURL = typeof String !== "undefined" && (image instanceof String || typeof image === "string");
+    let data;
+    let tensorConfig = {};
+    if (isHTMLImageEle) {
+      const canvas = document.createElement("canvas");
+      const pixels2DContext = canvas.getContext("2d");
+      if (pixels2DContext != null) {
+        let height = image.naturalHeight;
+        let width = image.naturalWidth;
+        if (options !== void 0 && options.resizedHeight !== void 0 && options.resizedWidth !== void 0) {
+          height = options.resizedHeight;
+          width = options.resizedWidth;
+        }
+        if (options !== void 0) {
+          tensorConfig = options;
+          if (options.tensorFormat !== void 0) {
+            throw new Error("Image input config format must be RGBA for HTMLImageElement");
+          } else {
+            tensorConfig.tensorFormat = "RGBA";
+          }
+          if (options.height !== void 0 && options.height !== height) {
+            throw new Error("Image input config height doesn't match HTMLImageElement height");
+          } else {
+            tensorConfig.height = height;
+          }
+          if (options.width !== void 0 && options.width !== width) {
+            throw new Error("Image input config width doesn't match HTMLImageElement width");
+          } else {
+            tensorConfig.width = width;
+          }
+        } else {
+          tensorConfig.tensorFormat = "RGBA";
+          tensorConfig.height = height;
+          tensorConfig.width = width;
+        }
+        canvas.width = width;
+        canvas.height = height;
+        pixels2DContext.drawImage(image, 0, 0, width, height);
+        data = pixels2DContext.getImageData(0, 0, width, height).data;
+      } else {
+        throw new Error("Can not access image data");
+      }
+    } else if (isImageDataEle) {
+      const format = "RGBA";
+      let height;
+      let width;
+      if (options !== void 0 && options.resizedWidth !== void 0 && options.resizedHeight !== void 0) {
+        height = options.resizedHeight;
+        width = options.resizedWidth;
+      } else {
+        height = image.height;
+        width = image.width;
+      }
+      if (options !== void 0) {
+        tensorConfig = options;
+        if (options.bitmapFormat !== void 0 && options.bitmapFormat !== format) {
+          throw new Error("Image input config format must be RGBA for ImageData");
+        } else {
+          tensorConfig.bitmapFormat = "RGBA";
+        }
+      } else {
+        tensorConfig.bitmapFormat = "RGBA";
+      }
+      tensorConfig.height = height;
+      tensorConfig.width = width;
+      if (options !== void 0) {
+        const tempCanvas = document.createElement("canvas");
+        tempCanvas.width = width;
+        tempCanvas.height = height;
+        const pixels2DContext = tempCanvas.getContext("2d");
+        if (pixels2DContext != null) {
+          pixels2DContext.putImageData(image, 0, 0);
+          data = pixels2DContext.getImageData(0, 0, width, height).data;
+        } else {
+          throw new Error("Can not access image data");
+        }
+      } else {
+        data = image.data;
+      }
+    } else if (isImageBitmap) {
+      if (options === void 0) {
+        throw new Error("Please provide image config with format for Imagebitmap");
+      }
+      if (options.bitmapFormat !== void 0) {
+        throw new Error("Image input config format must be defined for ImageBitmap");
+      }
+      const pixels2DContext = document.createElement("canvas").getContext("2d");
+      if (pixels2DContext != null) {
+        const height = image.height;
+        const width = image.width;
+        pixels2DContext.drawImage(image, 0, 0, width, height);
+        data = pixels2DContext.getImageData(0, 0, width, height).data;
+        if (options !== void 0) {
+          if (options.height !== void 0 && options.height !== height) {
+            throw new Error("Image input config height doesn't match ImageBitmap height");
+          } else {
+            tensorConfig.height = height;
+          }
+          if (options.width !== void 0 && options.width !== width) {
+            throw new Error("Image input config width doesn't match ImageBitmap width");
+          } else {
+            tensorConfig.width = width;
+          }
+        } else {
+          tensorConfig.height = height;
+          tensorConfig.width = width;
+        }
+        return Tensor.bufferToTensor(data, tensorConfig);
+      } else {
+        throw new Error("Can not access image data");
+      }
+    } else if (isURL) {
+      return new Promise((resolve, reject) => {
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("2d");
+        if (!image || !context) {
+          return reject();
+        }
+        const newImage = new Image();
+        newImage.crossOrigin = "Anonymous";
+        newImage.src = image;
+        newImage.onload = () => {
+          canvas.width = newImage.width;
+          canvas.height = newImage.height;
+          context.drawImage(newImage, 0, 0, canvas.width, canvas.height);
+          const img = context.getImageData(0, 0, canvas.width, canvas.height);
+          if (options !== void 0) {
+            if (options.height !== void 0 && options.height !== canvas.height) {
+              throw new Error("Image input config height doesn't match ImageBitmap height");
+            } else {
+              tensorConfig.height = canvas.height;
+            }
+            if (options.width !== void 0 && options.width !== canvas.width) {
+              throw new Error("Image input config width doesn't match ImageBitmap width");
+            } else {
+              tensorConfig.width = canvas.width;
+            }
+          } else {
+            tensorConfig.height = canvas.height;
+            tensorConfig.width = canvas.width;
+          }
+          resolve(Tensor.bufferToTensor(img.data, tensorConfig));
+        };
+      });
+    } else {
+      throw new Error("Input data provided is not supported - aborted tensor creation");
+    }
+    if (data !== void 0) {
+      return Tensor.bufferToTensor(data, tensorConfig);
+    } else {
+      throw new Error("Input data provided is not supported - aborted tensor creation");
+    }
+  }
+  toImageData(options) {
+    var _a, _b;
+    const pixels2DContext = document.createElement("canvas").getContext("2d");
+    let image;
+    if (pixels2DContext != null) {
+      const width = this.dims[3];
+      const height = this.dims[2];
+      const channels = this.dims[1];
+      const inputformat = options !== void 0 ? options.format !== void 0 ? options.format : "RGB" : "RGB";
+      const normMean = options !== void 0 ? ((_a = options.norm) === null || _a === void 0 ? void 0 : _a.mean) !== void 0 ? options.norm.mean : 255 : 255;
+      const normBias = options !== void 0 ? ((_b = options.norm) === null || _b === void 0 ? void 0 : _b.bias) !== void 0 ? options.norm.bias : 0 : 0;
+      const offset = height * width;
+      if (options !== void 0) {
+        if (options.height !== void 0 && options.height !== height) {
+          throw new Error("Image output config height doesn't match tensor height");
+        }
+        if (options.width !== void 0 && options.width !== width) {
+          throw new Error("Image output config width doesn't match tensor width");
+        }
+        if (options.format !== void 0 && (channels === 4 && options.format !== "RGBA") || channels === 3 && (options.format !== "RGB" && options.format !== "BGR")) {
+          throw new Error("Tensor format doesn't match input tensor dims");
+        }
+      }
+      const step = 4;
+      let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
+      let rTensorPointer = 0, gTensorPointer = offset, bTensorPointer = offset * 2, aTensorPointer = -1;
+      if (inputformat === "RGBA") {
+        rTensorPointer = 0;
+        gTensorPointer = offset;
+        bTensorPointer = offset * 2;
+        aTensorPointer = offset * 3;
+      } else if (inputformat === "RGB") {
+        rTensorPointer = 0;
+        gTensorPointer = offset;
+        bTensorPointer = offset * 2;
+      } else if (inputformat === "RBG") {
+        rTensorPointer = 0;
+        bTensorPointer = offset;
+        gTensorPointer = offset * 2;
+      }
+      image = pixels2DContext.createImageData(width, height);
+      for (let i = 0; i < height * width; rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {
+        image.data[rImagePointer] = (this.data[rTensorPointer++] - normBias) * normMean;
+        image.data[gImagePointer] = (this.data[gTensorPointer++] - normBias) * normMean;
+        image.data[bImagePointer] = (this.data[bTensorPointer++] - normBias) * normMean;
+        image.data[aImagePointer] = aTensorPointer === -1 ? 255 : (this.data[aTensorPointer++] - normBias) * normMean;
+      }
+    } else {
+      throw new Error("Can not access image data");
+    }
+    return image;
+  }
+  // #endregion
+  // #region tensor utilities
+  reshape(dims) {
+    return new Tensor(this.type, this.data, dims);
+  }
+}
+export {
+  Tensor
+};
+//# sourceMappingURL=tensor-impl.js.map