@ztl-uwu/nuxt-content 2.13.5

package/dist/runtime/transformers/csv/create-tokenizer.js

@@ -0,0 +1,307 @@
+import { markdownLineEnding } from "micromark-util-character";
+import { push, splice } from "micromark-util-chunked";
+import { resolveAll } from "micromark-util-resolve-all";
+export function createTokenizer(parser, initialize, from) {
+  let point = Object.assign(
+    from ? Object.assign({}, from) : {
+      line: 1,
+      column: 1,
+      offset: 0
+    },
+    {
+      _index: 0,
+      _bufferIndex: -1
+    }
+  );
+  const columnStart = {};
+  const resolveAllConstructs = [];
+  let chunks = [];
+  let stack = [];
+  let consumed = true;
+  const effects = {
+    consume,
+    enter,
+    exit,
+    attempt: constructFactory(onsuccessfulconstruct),
+    check: constructFactory(onsuccessfulcheck),
+    interrupt: constructFactory(onsuccessfulcheck, {
+      interrupt: true
+    })
+  };
+  const context = {
+    previous: null,
+    code: null,
+    containerState: {},
+    events: [],
+    parser,
+    sliceStream,
+    sliceSerialize,
+    now,
+    defineSkip,
+    write
+  };
+  let state = initialize.tokenize.call(context, effects);
+  let expectedCode;
+  if (initialize.resolveAll) {
+    resolveAllConstructs.push(initialize);
+  }
+  return context;
+  function write(slice) {
+    chunks = push(chunks, slice);
+    main();
+    if (chunks[chunks.length - 1] !== null) {
+      return [];
+    }
+    addResult(initialize, 0);
+    context.events = resolveAll(resolveAllConstructs, context.events, context);
+    return context.events;
+  }
+  function sliceSerialize(token, expandTabs) {
+    return serializeChunks(sliceStream(token), expandTabs);
+  }
+  function sliceStream(token) {
+    return sliceChunks(chunks, token);
+  }
+  function now() {
+    return Object.assign({}, point);
+  }
+  function defineSkip(value) {
+    columnStart[value.line] = value.column;
+    accountForPotentialSkip();
+  }
+  function main() {
+    let chunkIndex;
+    while (point._index < chunks.length) {
+      const chunk = chunks[point._index];
+      if (typeof chunk === "string") {
+        chunkIndex = point._index;
+        if (point._bufferIndex < 0) {
+          point._bufferIndex = 0;
+        }
+        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {
+          go(chunk.charCodeAt(point._bufferIndex));
+        }
+      } else {
+        go(chunk);
+      }
+    }
+  }
+  function go(code) {
+    consumed = void 0;
+    expectedCode = code;
+    state = state(code);
+  }
+  function consume(code) {
+    if (markdownLineEnding(code)) {
+      point.line++;
+      point.column = 1;
+      point.offset += code === -3 ? 2 : 1;
+      accountForPotentialSkip();
+    } else if (code !== -1) {
+      point.column++;
+      point.offset++;
+    }
+    if (point._bufferIndex < 0) {
+      point._index++;
+    } else {
+      point._bufferIndex++;
+      if (point._bufferIndex === chunks[point._index].length) {
+        point._bufferIndex = -1;
+        point._index++;
+      }
+    }
+    context.previous = code;
+    consumed = true;
+  }
+  function enter(type, fields) {
+    const token = fields || {};
+    token.type = type;
+    token.start = now();
+    context.events.push(["enter", token, context]);
+    stack.push(token);
+    return token;
+  }
+  function exit(type) {
+    const token = stack.pop();
+    token.end = now();
+    context.events.push(["exit", token, context]);
+    return token;
+  }
+  function onsuccessfulconstruct(construct, info) {
+    addResult(construct, info.from);
+  }
+  function onsuccessfulcheck(_, info) {
+    info.restore();
+  }
+  function constructFactory(onreturn, fields) {
+    return hook;
+    function hook(constructs, returnState, bogusState) {
+      let listOfConstructs;
+      let constructIndex;
+      let currentConstruct;
+      let info;
+      return Array.isArray(constructs) ? (
+        /* c8 ignore next 1 */
+        handleListOfConstructs(constructs)
+      ) : "tokenize" in constructs ? handleListOfConstructs([constructs]) : handleMapOfConstructs(constructs);
+      function handleMapOfConstructs(map) {
+        return start;
+        function start(code) {
+          const def = code !== null && map[code];
+          const all = code !== null && map.null;
+          const list = [
+            // To do: add more extension tests.
+            /* c8 ignore next 2 */
+            ...Array.isArray(def) ? def : def ? [def] : [],
+            ...Array.isArray(all) ? all : all ? [all] : []
+          ];
+          return handleListOfConstructs(list)(code);
+        }
+      }
+      function handleListOfConstructs(list) {
+        listOfConstructs = list;
+        constructIndex = 0;
+        if (list.length === 0) {
+          return bogusState;
+        }
+        return handleConstruct(list[constructIndex]);
+      }
+      function handleConstruct(construct) {
+        return start;
+        function start(code) {
+          info = store();
+          currentConstruct = construct;
+          if (!construct.partial) {
+            context.currentConstruct = construct;
+          }
+          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {
+            return nok(code);
+          }
+          return construct.tokenize.call(
+            // If we do have fields, create an object w/ `context` as its
+            // prototype.
+            // This allows a “live binding”, which is needed for `interrupt`.
+            fields ? Object.assign(Object.create(context), fields) : context,
+            effects,
+            ok,
+            nok
+          )(code);
+        }
+      }
+      function ok(code) {
+        consumed = true;
+        onreturn(currentConstruct, info);
+        return returnState;
+      }
+      function nok(code) {
+        consumed = true;
+        info.restore();
+        if (++constructIndex < listOfConstructs.length) {
+          return handleConstruct(listOfConstructs[constructIndex]);
+        }
+        return bogusState;
+      }
+    }
+  }
+  function addResult(construct, from2) {
+    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {
+      resolveAllConstructs.push(construct);
+    }
+    if (construct.resolve) {
+      splice(
+        context.events,
+        from2,
+        context.events.length - from2,
+        construct.resolve(context.events.slice(from2), context)
+      );
+    }
+    if (construct.resolveTo) {
+      context.events = construct.resolveTo(context.events, context);
+    }
+  }
+  function store() {
+    const startPoint = now();
+    const startPrevious = context.previous;
+    const startCurrentConstruct = context.currentConstruct;
+    const startEventsIndex = context.events.length;
+    const startStack = Array.from(stack);
+    return {
+      restore,
+      from: startEventsIndex
+    };
+    function restore() {
+      point = startPoint;
+      context.previous = startPrevious;
+      context.currentConstruct = startCurrentConstruct;
+      context.events.length = startEventsIndex;
+      stack = startStack;
+      accountForPotentialSkip();
+    }
+  }
+  function accountForPotentialSkip() {
+    if (point.line in columnStart && point.column < 2) {
+      point.column = columnStart[point.line];
+      point.offset += columnStart[point.line] - 1;
+    }
+  }
+}
+function sliceChunks(chunks, token) {
+  const startIndex = token.start._index;
+  const startBufferIndex = token.start._bufferIndex;
+  const endIndex = token.end._index;
+  const endBufferIndex = token.end._bufferIndex;
+  let view;
+  if (startIndex === endIndex) {
+    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];
+  } else {
+    view = chunks.slice(startIndex, endIndex);
+    if (startBufferIndex > -1) {
+      view[0] = view[0].slice(startBufferIndex);
+    }
+    if (endBufferIndex > 0) {
+      view.push(chunks[endIndex].slice(0, endBufferIndex));
+    }
+  }
+  return view;
+}
+function serializeChunks(chunks, expandTabs) {
+  let index = -1;
+  const result = [];
+  let atTab;
+  while (++index < chunks.length) {
+    const chunk = chunks[index];
+    let value;
+    if (typeof chunk === "string") {
+      value = chunk;
+    } else
+      switch (chunk) {
+        case -5: {
+          value = "\r";
+          break;
+        }
+        case -4: {
+          value = "\n";
+          break;
+        }
+        case -3: {
+          value = "\r\n";
+          break;
+        }
+        case -2: {
+          value = expandTabs ? " " : "	";
+          break;
+        }
+        case -1: {
+          if (!expandTabs && atTab) continue;
+          value = " ";
+          break;
+        }
+        default: {
+          value = String.fromCharCode(chunk);
+        }
+      }
+    atTab = chunk === -2;
+    result.push(value);
+  }
+  return result.join("");
+}

package/dist/runtime/transformers/csv/from-csv.d.ts

@@ -0,0 +1,13 @@
+import type { Point as MPoint } from 'micromark-util-types';
+type Point = Omit<MPoint, '_index' | '_bufferIndex'>;
+type Node = {
+    type: string;
+    children: Array<Node>;
+    position?: {
+        start?: Point;
+        end?: Point;
+    };
+    value?: string;
+};
+export declare const fromCSV: (value: any, encoding?: any, options?: any) => Node;
+export {};

package/dist/runtime/transformers/csv/from-csv.js

@@ -0,0 +1,203 @@
+import { toString } from "mdast-util-to-string";
+import { preprocess, postprocess } from "micromark";
+import { stringifyPosition } from "unist-util-stringify-position";
+import { parse } from "./parser.js";
+const own = {}.hasOwnProperty;
+const initialPoint = {
+  line: 1,
+  column: 1,
+  offset: 0
+};
+export const fromCSV = function(value, encoding, options) {
+  if (typeof encoding !== "string") {
+    options = encoding;
+    encoding = void 0;
+  }
+  return compiler()(
+    postprocess(
+      parse(options).write(preprocess()(value, encoding, true))
+    )
+  );
+};
+function compiler() {
+  const config = {
+    enter: {
+      column: opener(openColumn),
+      row: opener(openRow),
+      data: onenterdata,
+      quotedData: onenterdata
+    },
+    exit: {
+      row: closer(),
+      column: closer(),
+      data: onexitdata,
+      quotedData: onexitQuotedData
+    }
+  };
+  return compile;
+  function compile(events) {
+    const tree = {
+      type: "root",
+      children: []
+    };
+    const stack = [tree];
+    const tokenStack = [];
+    const context = {
+      stack,
+      tokenStack,
+      config,
+      enter,
+      exit,
+      resume
+    };
+    let index = -1;
+    while (++index < events.length) {
+      const handler = config[events[index][0]];
+      if (own.call(handler, events[index][1].type)) {
+        handler[events[index][1].type].call(
+          Object.assign(
+            {
+              sliceSerialize: events[index][2].sliceSerialize
+            },
+            context
+          ),
+          events[index][1]
+        );
+      }
+    }
+    if (tokenStack.length > 0) {
+      const tail = tokenStack[tokenStack.length - 1];
+      const handler = tail[1] || defaultOnError;
+      handler.call(context, void 0, tail[0]);
+    }
+    tree.position = {
+      start: point(
+        events.length > 0 ? events[0][1].start : initialPoint
+      ),
+      end: point(
+        events.length > 0 ? events[events.length - 2][1].end : initialPoint
+      )
+    };
+    return tree;
+  }
+  function point(d) {
+    return {
+      line: d.line,
+      column: d.column,
+      offset: d.offset
+    };
+  }
+  function opener(create, and) {
+    return open;
+    function open(token) {
+      enter.call(this, create(token), token);
+      if (and) {
+        and.call(this, token);
+      }
+    }
+  }
+  function enter(node, token, errorHandler) {
+    const parent = this.stack[this.stack.length - 1];
+    parent.children.push(node);
+    this.stack.push(node);
+    this.tokenStack.push([token, errorHandler]);
+    node.position = {
+      start: point(token.start)
+    };
+    return node;
+  }
+  function closer(and) {
+    return close;
+    function close(token) {
+      if (and) {
+        and.call(this, token);
+      }
+      exit.call(this, token);
+    }
+  }
+  function exit(token, onExitError) {
+    const node = this.stack.pop();
+    const open = this.tokenStack.pop();
+    if (!open) {
+      throw new Error(
+        "Cannot close `" + token.type + "` (" + stringifyPosition({
+          start: token.start,
+          end: token.end
+        }) + "): it\u2019s not open"
+      );
+    } else if (open[0].type !== token.type) {
+      if (onExitError) {
+        onExitError.call(this, token, open[0]);
+      } else {
+        const handler = open[1] || defaultOnError;
+        handler.call(this, token, open[0]);
+      }
+    }
+    node.position.end = point(token.end);
+    return node;
+  }
+  function resume() {
+    return toString(this.stack.pop());
+  }
+  function onenterdata(token) {
+    const parent = this.stack[this.stack.length - 1];
+    let tail = parent.children[parent.children.length - 1];
+    if (!tail || tail.type !== "text") {
+      tail = text();
+      tail.position = {
+        start: point(token.start)
+      };
+      parent.children.push(tail);
+    }
+    this.stack.push(tail);
+  }
+  function onexitdata(token) {
+    const tail = this.stack.pop();
+    tail.value += this.sliceSerialize(token).trim().replace(/""/g, '"');
+    tail.position.end = point(token.end);
+  }
+  function onexitQuotedData(token) {
+    const tail = this.stack.pop();
+    const value = this.sliceSerialize(token);
+    tail.value += this.sliceSerialize(token).trim().substring(1, value.length - 1).replace(/""/g, '"');
+    tail.position.end = point(token.end);
+  }
+  function text() {
+    return {
+      type: "text",
+      value: ""
+    };
+  }
+  function openColumn() {
+    return {
+      type: "column",
+      children: []
+    };
+  }
+  function openRow() {
+    return {
+      type: "row",
+      children: []
+    };
+  }
+}
+function defaultOnError(left, right) {
+  if (left) {
+    throw new Error(
+      "Cannot close `" + left.type + "` (" + stringifyPosition({
+        start: left.start,
+        end: left.end
+      }) + "): a different token (`" + right.type + "`, " + stringifyPosition({
+        start: right.start,
+        end: right.end
+      }) + ") is open"
+    );
+  } else {
+    throw new Error(
+      "Cannot close document, a token (`" + right.type + "`, " + stringifyPosition({
+        start: right.start,
+        end: right.end
+      }) + ") is still open"
+    );
+  }
+}

package/dist/runtime/transformers/csv/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: ContentTransformer;
+export default _default;

package/dist/runtime/transformers/csv/index.js

@@ -0,0 +1,50 @@
+import { unified } from "unified";
+import { defineTransformer } from "../utils.js";
+import { fromCSV } from "./from-csv.js";
+function csvParse(options) {
+  const parser = (doc) => {
+    return fromCSV(doc, options);
+  };
+  Object.assign(this, { Parser: parser });
+  const toJsonObject = (tree) => {
+    const [header, ...rows] = tree.children;
+    const columns = header.children.map((col) => col.children[0].value);
+    const data = rows.map((row) => {
+      return row.children.reduce((acc, col, i) => {
+        acc[String(columns[i])] = col.children[0]?.value;
+        return acc;
+      }, {});
+    });
+    return data;
+  };
+  const toJsonArray = (tree) => {
+    const data = tree.children.map((row) => {
+      return row.children.map((col) => col.children[0]?.value);
+    });
+    return data;
+  };
+  const compiler = (doc) => {
+    if (options.json) {
+      return toJsonObject(doc);
+    }
+    return toJsonArray(doc);
+  };
+  Object.assign(this, { Compiler: compiler });
+}
+export default defineTransformer({
+  name: "csv",
+  extensions: [".csv"],
+  parse: async (_id, content, options = {}) => {
+    const stream = unified().use(csvParse, {
+      delimiter: ",",
+      json: true,
+      ...options
+    });
+    const { result } = await stream.process(content);
+    return {
+      _id,
+      _type: "csv",
+      body: result
+    };
+  }
+});

package/dist/runtime/transformers/csv/parser.d.ts

@@ -0,0 +1,24 @@
+declare module 'micromark-util-types' {
+    interface TokenTypeMap {
+        row: 'row';
+        column: 'column';
+        columnSeparator: 'columnSeparator';
+        newline: 'newline';
+        quotedData: 'quotedData';
+        quotedDataChunk: 'quotedDataChunk';
+        quoteFence: 'quoteFence';
+        emptyLine: 'emptyLine';
+    }
+}
+export declare const parse: (options: any) => {
+    previous: null;
+    code: null;
+    containerState: {};
+    events: never[];
+    parser: any;
+    sliceStream: (token: any) => any;
+    sliceSerialize: (token: any, expandTabs: any) => string;
+    now: () => any;
+    defineSkip: (value: any) => void;
+    write: (slice: any) => never[];
+};