chore: update node_modules with new binary files and dependencies

- Add new binary files for nodemon, onnxruntime-web, and xenova/transformers
- Update various JavaScript and TypeScript files in node_modules
- Remove unused files and dependencies
- Add new test fixtures and documentation files

node_modules/onnxruntime-web/lib/onnxjs/backends/webgl/ops/split.ts

@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {AttributeWithCacheKey, createAttributeWithCacheKey} from '../../../attribute-with-cache-key';
+import {Graph} from '../../../graph';
+import {OperatorImplementation, OperatorInitialization} from '../../../operators';
+import {Tensor} from '../../../tensor';
+import {ShapeUtil, SplitUtil} from '../../../util';
+import {WebGLInferenceHandler} from '../inference-handler';
+import {ProgramInfo, TextureType} from '../types';
+
+export interface SplitAttributes extends AttributeWithCacheKey {
+  readonly axis: number;
+  readonly split: number[];
+  readonly numOutputs: number;
+}
+
+const splitProgramMetadata = {
+  name: 'Split',
+  inputNames: ['A'],
+  inputTypes: [TextureType.unpacked],
+};
+
+export const split: OperatorImplementation<SplitAttributes> =
+    (inferenceHandler: WebGLInferenceHandler, inputs: Tensor[], attributes: SplitAttributes): Tensor[] => {
+      validateInputs(inputs);
+
+      const axis = ShapeUtil.normalizeAxis(attributes.axis, inputs[0].dims.length);
+      const count = getProgramCount(inferenceHandler, inputs, axis, attributes);
+      const output: Tensor[] = [];
+      for (let i = 0; i < count; ++i) {
+        output.push(inferenceHandler.run(
+            {
+              ...splitProgramMetadata,
+              cacheHint: `${attributes.cacheKey};${i}`,
+              get: () => createSplitProgramInfo(inferenceHandler, inputs[0], attributes, axis, i)
+            },
+            inputs));
+      }
+
+      return output;
+    };
+
+export const parseSplitAttributes: OperatorInitialization<SplitAttributes> = (node: Graph.Node): SplitAttributes => {
+  const axis = node.attributes.getInt('axis', 0);
+  const split = node.attributes.getInts('split', []);
+  const numOutputs = node.outputs.length;
+  return createAttributeWithCacheKey({axis, split, numOutputs});
+};
+
+const getProgramCount =
+    (inferenceHandler: WebGLInferenceHandler, inputs: Tensor[], axis: number, attributes: SplitAttributes): number => {
+      const [, offsets] = SplitUtil.splitShape(inputs[0].dims, axis, attributes.split, attributes.numOutputs);
+      return offsets.length;
+    };
+
+const createSplitProgramInfo =
+    (inferenceHandler: WebGLInferenceHandler, input: Tensor, attributes: SplitAttributes, axis: number, index: number):
+        ProgramInfo => {
+          const [shapes, offsets] = SplitUtil.splitShape(input.dims, axis, attributes.split, attributes.numOutputs);
+          const offset = offsets[index];
+          const outputShape = shapes[index];
+          const rank = outputShape.length;
+          const shaderSource = `
+      float process(int indices[${rank}]) {
+        indices[${axis}] += ${offset};
+        return _A(indices);
+      }
+    `;
+          return {
+            ...splitProgramMetadata,
+            cacheHint: `${attributes.cacheKey}:${index}`,
+            output: {dims: outputShape, type: input.type, textureType: TextureType.unpacked},
+            shaderSource
+          };
+        };
+
+const validateInputs = (inputs: Tensor[]): void => {
+  if (!inputs || inputs.length !== 1) {
+    throw new Error('Split requires one input.');
+  }
+
+  if (inputs[0].type !== 'int8' && inputs[0].type !== 'uint8' && inputs[0].type !== 'int16' &&
+      inputs[0].type !== 'uint16' && inputs[0].type !== 'int32' && inputs[0].type !== 'uint32' &&
+      inputs[0].type !== 'float32' && inputs[0].type !== 'float64' && inputs[0].type !== 'bool') {
+    throw new Error('Invalid input type.');
+  }
+};