@inventreedb/ui 0.0.1 → 0.0.3

package/dist/node_modules/@messageformat/parser/lib/parser.js

@@ -0,0 +1,223 @@
+import { __exports as parser } from "../../../../_virtual/parser2.js";
+import { __require as requireLexer } from "./lexer.js";
+var hasRequiredParser;
+function requireParser() {
+  if (hasRequiredParser) return parser;
+  hasRequiredParser = 1;
+  Object.defineProperty(parser, "__esModule", { value: true });
+  parser.parse = parser.ParseError = void 0;
+  const lexer_js_1 = requireLexer();
+  const getContext = (lt) => ({
+    offset: lt.offset,
+    line: lt.line,
+    col: lt.col,
+    text: lt.text,
+    lineBreaks: lt.lineBreaks
+  });
+  const isSelectType = (type) => type === "plural" || type === "select" || type === "selectordinal";
+  function strictArgStyleParam(lt, param) {
+    let value = "";
+    let text = "";
+    for (const p of param) {
+      const pText = p.ctx.text;
+      text += pText;
+      switch (p.type) {
+        case "content":
+          value += p.value;
+          break;
+        case "argument":
+        case "function":
+        case "octothorpe":
+          value += pText;
+          break;
+        default:
+          throw new ParseError(lt, `Unsupported part in strict mode function arg style: ${pText}`);
+      }
+    }
+    const c = {
+      type: "content",
+      value: value.trim(),
+      ctx: Object.assign({}, param[0].ctx, { text })
+    };
+    return [c];
+  }
+  const strictArgTypes = [
+    "number",
+    "date",
+    "time",
+    "spellout",
+    "ordinal",
+    "duration"
+  ];
+  const defaultPluralKeys = ["zero", "one", "two", "few", "many", "other"];
+  class ParseError extends Error {
+    /** @internal */
+    constructor(lt, msg) {
+      super(lexer_js_1.lexer.formatError(lt, msg));
+    }
+  }
+  parser.ParseError = ParseError;
+  class Parser {
+    constructor(src, opt) {
+      var _a, _b, _c, _d;
+      this.lexer = lexer_js_1.lexer.reset(src);
+      this.cardinalKeys = (_a = opt === null || opt === void 0 ? void 0 : opt.cardinal) !== null && _a !== void 0 ? _a : defaultPluralKeys;
+      this.ordinalKeys = (_b = opt === null || opt === void 0 ? void 0 : opt.ordinal) !== null && _b !== void 0 ? _b : defaultPluralKeys;
+      this.strict = (_c = opt === null || opt === void 0 ? void 0 : opt.strict) !== null && _c !== void 0 ? _c : false;
+      this.strictPluralKeys = (_d = opt === null || opt === void 0 ? void 0 : opt.strictPluralKeys) !== null && _d !== void 0 ? _d : true;
+    }
+    parse() {
+      return this.parseBody(false, true);
+    }
+    checkSelectKey(lt, type, key) {
+      if (key[0] === "=") {
+        if (type === "select")
+          throw new ParseError(lt, `The case ${key} is not valid with select`);
+      } else if (type !== "select") {
+        const keys = type === "plural" ? this.cardinalKeys : this.ordinalKeys;
+        if (this.strictPluralKeys && keys.length > 0 && !keys.includes(key)) {
+          const msg = `The ${type} case ${key} is not valid in this locale`;
+          throw new ParseError(lt, msg);
+        }
+      }
+    }
+    parseSelect({ value: arg }, inPlural, ctx, type) {
+      const sel = { type, arg, cases: [], ctx };
+      if (type === "plural" || type === "selectordinal")
+        inPlural = true;
+      else if (this.strict)
+        inPlural = false;
+      for (const lt of this.lexer) {
+        switch (lt.type) {
+          case "offset":
+            if (type === "select")
+              throw new ParseError(lt, "Unexpected plural offset for select");
+            if (sel.cases.length > 0)
+              throw new ParseError(lt, "Plural offset must be set before cases");
+            sel.pluralOffset = Number(lt.value);
+            ctx.text += lt.text;
+            ctx.lineBreaks += lt.lineBreaks;
+            break;
+          case "case": {
+            this.checkSelectKey(lt, type, lt.value);
+            sel.cases.push({
+              key: lt.value,
+              tokens: this.parseBody(inPlural),
+              ctx: getContext(lt)
+            });
+            break;
+          }
+          case "end":
+            return sel;
+          /* istanbul ignore next: never happens */
+          default:
+            throw new ParseError(lt, `Unexpected lexer token: ${lt.type}`);
+        }
+      }
+      throw new ParseError(null, "Unexpected message end");
+    }
+    parseArgToken(lt, inPlural) {
+      const ctx = getContext(lt);
+      const argType = this.lexer.next();
+      if (!argType)
+        throw new ParseError(null, "Unexpected message end");
+      ctx.text += argType.text;
+      ctx.lineBreaks += argType.lineBreaks;
+      if (this.strict && (argType.type === "func-simple" || argType.type === "func-args") && !strictArgTypes.includes(argType.value)) {
+        const msg = `Invalid strict mode function arg type: ${argType.value}`;
+        throw new ParseError(lt, msg);
+      }
+      switch (argType.type) {
+        case "end":
+          return { type: "argument", arg: lt.value, ctx };
+        case "func-simple": {
+          const end = this.lexer.next();
+          if (!end)
+            throw new ParseError(null, "Unexpected message end");
+          if (end.type !== "end")
+            throw new ParseError(end, `Unexpected lexer token: ${end.type}`);
+          ctx.text += end.text;
+          if (isSelectType(argType.value.toLowerCase()))
+            throw new ParseError(argType, `Invalid type identifier: ${argType.value}`);
+          return {
+            type: "function",
+            arg: lt.value,
+            key: argType.value,
+            ctx
+          };
+        }
+        case "func-args": {
+          if (isSelectType(argType.value.toLowerCase())) {
+            const msg = `Invalid type identifier: ${argType.value}`;
+            throw new ParseError(argType, msg);
+          }
+          let param = this.parseBody(this.strict ? false : inPlural);
+          if (this.strict && param.length > 0)
+            param = strictArgStyleParam(lt, param);
+          return {
+            type: "function",
+            arg: lt.value,
+            key: argType.value,
+            param,
+            ctx
+          };
+        }
+        case "select":
+          if (isSelectType(argType.value))
+            return this.parseSelect(lt, inPlural, ctx, argType.value);
+          else
+            throw new ParseError(argType, `Unexpected select type ${argType.value}`);
+        /* istanbul ignore next: never happens */
+        default:
+          throw new ParseError(argType, `Unexpected lexer token: ${argType.type}`);
+      }
+    }
+    parseBody(inPlural, atRoot) {
+      const tokens = [];
+      let content = null;
+      for (const lt of this.lexer) {
+        if (lt.type === "argument") {
+          if (content)
+            content = null;
+          tokens.push(this.parseArgToken(lt, inPlural));
+        } else if (lt.type === "octothorpe" && inPlural) {
+          if (content)
+            content = null;
+          tokens.push({ type: "octothorpe", ctx: getContext(lt) });
+        } else if (lt.type === "end" && !atRoot) {
+          return tokens;
+        } else {
+          let value = lt.value;
+          if (!inPlural && lt.type === "quoted" && value[0] === "#") {
+            if (value.includes("{")) {
+              const errMsg = `Unsupported escape pattern: ${value}`;
+              throw new ParseError(lt, errMsg);
+            }
+            value = lt.text;
+          }
+          if (content) {
+            content.value += value;
+            content.ctx.text += lt.text;
+            content.ctx.lineBreaks += lt.lineBreaks;
+          } else {
+            content = { type: "content", value, ctx: getContext(lt) };
+            tokens.push(content);
+          }
+        }
+      }
+      if (atRoot)
+        return tokens;
+      throw new ParseError(null, "Unexpected message end");
+    }
+  }
+  function parse(src, options = {}) {
+    const parser2 = new Parser(src, options);
+    return parser2.parse();
+  }
+  parser.parse = parse;
+  return parser;
+}
+export {
+  requireParser as __require
+};
+//# sourceMappingURL=parser.js.map

package/dist/node_modules/@messageformat/parser/lib/parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.js","sources":["../../../../../node_modules/@messageformat/parser/lib/parser.js"],"sourcesContent":["\"use strict\";\n/**\n * An AST parser for ICU MessageFormat strings\n *\n * @packageDocumentation\n * @example\n * ```\n * import { parse } from '@messageformat/parser\n *\n * parse('So {wow}.')\n * [ { type: 'content', value: 'So ' },\n *   { type: 'argument', arg: 'wow' },\n *   { type: 'content', value: '.' } ]\n *\n *\n * parse('Such { thing }. { count, selectordinal, one {First} two {Second}' +\n *       '                  few {Third} other {#th} } word.')\n * [ { type: 'content', value: 'Such ' },\n *   { type: 'argument', arg: 'thing' },\n *   { type: 'content', value: '. ' },\n *   { type: 'selectordinal',\n *     arg: 'count',\n *     cases: [\n *       { key: 'one', tokens: [ { type: 'content', value: 'First' } ] },\n *       { key: 'two', tokens: [ { type: 'content', value: 'Second' } ] },\n *       { key: 'few', tokens: [ { type: 'content', value: 'Third' } ] },\n *       { key: 'other',\n *         tokens: [ { type: 'octothorpe' }, { type: 'content', value: 'th' } ] }\n *     ] },\n *   { type: 'content', value: ' word.' } ]\n *\n *\n * parse('Many{type,select,plural{ numbers}selectordinal{ counting}' +\n *                          'select{ choices}other{ some {type}}}.')\n * [ { type: 'content', value: 'Many' },\n *   { type: 'select',\n *     arg: 'type',\n *     cases: [\n *       { key: 'plural', tokens: [ { type: 'content', value: 'numbers' } ] },\n *       { key: 'selectordinal', tokens: [ { type: 'content', value: 'counting' } ] },\n *       { key: 'select', tokens: [ { type: 'content', value: 'choices' } ] },\n *       { key: 'other',\n *         tokens: [ { type: 'content', value: 'some ' }, { type: 'argument', arg: 'type' } ] }\n *     ] },\n *   { type: 'content', value: '.' } ]\n *\n *\n * parse('{Such compliance')\n * // ParseError: invalid syntax at line 1 col 7:\n * //\n * //  {Such compliance\n * //        ^\n *\n *\n * const msg = '{words, plural, zero{No words} one{One word} other{# words}}'\n * parse(msg)\n * [ { type: 'plural',\n *     arg: 'words',\n *     cases: [\n *       { key: 'zero', tokens: [ { type: 'content', value: 'No words' } ] },\n *       { key: 'one', tokens: [ { type: 'content', value: 'One word' } ] },\n *       { key: 'other',\n *         tokens: [ { type: 'octothorpe' }, { type: 'content', value: ' words' } ] }\n *     ] } ]\n *\n *\n * parse(msg, { cardinal: [ 'one', 'other' ], ordinal: [ 'one', 'two', 'few', 'other' ] })\n * // ParseError: The plural case zero is not valid in this locale at line 1 col 17:\n * //\n * //   {words, plural, zero{\n * //                   ^\n * ```\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parse = exports.ParseError = void 0;\nconst lexer_js_1 = require(\"./lexer.js\");\nconst getContext = (lt) => ({\n    offset: lt.offset,\n    line: lt.line,\n    col: lt.col,\n    text: lt.text,\n    lineBreaks: lt.lineBreaks\n});\nconst isSelectType = (type) => type === 'plural' || type === 'select' || type === 'selectordinal';\nfunction strictArgStyleParam(lt, param) {\n    let value = '';\n    let text = '';\n    for (const p of param) {\n        const pText = p.ctx.text;\n        text += pText;\n        switch (p.type) {\n            case 'content':\n                value += p.value;\n                break;\n            case 'argument':\n            case 'function':\n            case 'octothorpe':\n                value += pText;\n                break;\n            default:\n                throw new ParseError(lt, `Unsupported part in strict mode function arg style: ${pText}`);\n        }\n    }\n    const c = {\n        type: 'content',\n        value: value.trim(),\n        ctx: Object.assign({}, param[0].ctx, { text })\n    };\n    return [c];\n}\nconst strictArgTypes = [\n    'number',\n    'date',\n    'time',\n    'spellout',\n    'ordinal',\n    'duration'\n];\nconst defaultPluralKeys = ['zero', 'one', 'two', 'few', 'many', 'other'];\n/**\n * Thrown by {@link parse} on error\n *\n * @public\n */\nclass ParseError extends Error {\n    /** @internal */\n    constructor(lt, msg) {\n        super(lexer_js_1.lexer.formatError(lt, msg));\n    }\n}\nexports.ParseError = ParseError;\nclass Parser {\n    constructor(src, opt) {\n        var _a, _b, _c, _d;\n        this.lexer = lexer_js_1.lexer.reset(src);\n        this.cardinalKeys = (_a = opt === null || opt === void 0 ? void 0 : opt.cardinal) !== null && _a !== void 0 ? _a : defaultPluralKeys;\n        this.ordinalKeys = (_b = opt === null || opt === void 0 ? void 0 : opt.ordinal) !== null && _b !== void 0 ? _b : defaultPluralKeys;\n        this.strict = (_c = opt === null || opt === void 0 ? void 0 : opt.strict) !== null && _c !== void 0 ? _c : false;\n        this.strictPluralKeys = (_d = opt === null || opt === void 0 ? void 0 : opt.strictPluralKeys) !== null && _d !== void 0 ? _d : true;\n    }\n    parse() {\n        return this.parseBody(false, true);\n    }\n    checkSelectKey(lt, type, key) {\n        if (key[0] === '=') {\n            if (type === 'select')\n                throw new ParseError(lt, `The case ${key} is not valid with select`);\n        }\n        else if (type !== 'select') {\n            const keys = type === 'plural' ? this.cardinalKeys : this.ordinalKeys;\n            if (this.strictPluralKeys && keys.length > 0 && !keys.includes(key)) {\n                const msg = `The ${type} case ${key} is not valid in this locale`;\n                throw new ParseError(lt, msg);\n            }\n        }\n    }\n    parseSelect({ value: arg }, inPlural, ctx, type) {\n        const sel = { type, arg, cases: [], ctx };\n        if (type === 'plural' || type === 'selectordinal')\n            inPlural = true;\n        else if (this.strict)\n            inPlural = false;\n        for (const lt of this.lexer) {\n            switch (lt.type) {\n                case 'offset':\n                    if (type === 'select')\n                        throw new ParseError(lt, 'Unexpected plural offset for select');\n                    if (sel.cases.length > 0)\n                        throw new ParseError(lt, 'Plural offset must be set before cases');\n                    sel.pluralOffset = Number(lt.value);\n                    ctx.text += lt.text;\n                    ctx.lineBreaks += lt.lineBreaks;\n                    break;\n                case 'case': {\n                    this.checkSelectKey(lt, type, lt.value);\n                    sel.cases.push({\n                        key: lt.value,\n                        tokens: this.parseBody(inPlural),\n                        ctx: getContext(lt)\n                    });\n                    break;\n                }\n                case 'end':\n                    return sel;\n                /* istanbul ignore next: never happens */\n                default:\n                    throw new ParseError(lt, `Unexpected lexer token: ${lt.type}`);\n            }\n        }\n        throw new ParseError(null, 'Unexpected message end');\n    }\n    parseArgToken(lt, inPlural) {\n        const ctx = getContext(lt);\n        const argType = this.lexer.next();\n        if (!argType)\n            throw new ParseError(null, 'Unexpected message end');\n        ctx.text += argType.text;\n        ctx.lineBreaks += argType.lineBreaks;\n        if (this.strict &&\n            (argType.type === 'func-simple' || argType.type === 'func-args') &&\n            !strictArgTypes.includes(argType.value)) {\n            const msg = `Invalid strict mode function arg type: ${argType.value}`;\n            throw new ParseError(lt, msg);\n        }\n        switch (argType.type) {\n            case 'end':\n                return { type: 'argument', arg: lt.value, ctx };\n            case 'func-simple': {\n                const end = this.lexer.next();\n                if (!end)\n                    throw new ParseError(null, 'Unexpected message end');\n                /* istanbul ignore if: never happens */\n                if (end.type !== 'end')\n                    throw new ParseError(end, `Unexpected lexer token: ${end.type}`);\n                ctx.text += end.text;\n                if (isSelectType(argType.value.toLowerCase()))\n                    throw new ParseError(argType, `Invalid type identifier: ${argType.value}`);\n                return {\n                    type: 'function',\n                    arg: lt.value,\n                    key: argType.value,\n                    ctx\n                };\n            }\n            case 'func-args': {\n                if (isSelectType(argType.value.toLowerCase())) {\n                    const msg = `Invalid type identifier: ${argType.value}`;\n                    throw new ParseError(argType, msg);\n                }\n                let param = this.parseBody(this.strict ? false : inPlural);\n                if (this.strict && param.length > 0)\n                    param = strictArgStyleParam(lt, param);\n                return {\n                    type: 'function',\n                    arg: lt.value,\n                    key: argType.value,\n                    param,\n                    ctx\n                };\n            }\n            case 'select':\n                /* istanbul ignore else: never happens */\n                if (isSelectType(argType.value))\n                    return this.parseSelect(lt, inPlural, ctx, argType.value);\n                else\n                    throw new ParseError(argType, `Unexpected select type ${argType.value}`);\n            /* istanbul ignore next: never happens */\n            default:\n                throw new ParseError(argType, `Unexpected lexer token: ${argType.type}`);\n        }\n    }\n    parseBody(inPlural, atRoot) {\n        const tokens = [];\n        let content = null;\n        for (const lt of this.lexer) {\n            if (lt.type === 'argument') {\n                if (content)\n                    content = null;\n                tokens.push(this.parseArgToken(lt, inPlural));\n            }\n            else if (lt.type === 'octothorpe' && inPlural) {\n                if (content)\n                    content = null;\n                tokens.push({ type: 'octothorpe', ctx: getContext(lt) });\n            }\n            else if (lt.type === 'end' && !atRoot) {\n                return tokens;\n            }\n            else {\n                let value = lt.value;\n                if (!inPlural && lt.type === 'quoted' && value[0] === '#') {\n                    if (value.includes('{')) {\n                        const errMsg = `Unsupported escape pattern: ${value}`;\n                        throw new ParseError(lt, errMsg);\n                    }\n                    value = lt.text;\n                }\n                if (content) {\n                    content.value += value;\n                    content.ctx.text += lt.text;\n                    content.ctx.lineBreaks += lt.lineBreaks;\n                }\n                else {\n                    content = { type: 'content', value, ctx: getContext(lt) };\n                    tokens.push(content);\n                }\n            }\n        }\n        if (atRoot)\n            return tokens;\n        throw new ParseError(null, 'Unexpected message end');\n    }\n}\n/**\n * Parse an input string into an array of tokens\n *\n * @public\n * @remarks\n * The parser only supports the default `DOUBLE_OPTIONAL`\n * {@link http://www.icu-project.org/apiref/icu4c/messagepattern_8h.html#af6e0757e0eb81c980b01ee5d68a9978b | apostrophe mode}.\n */\nfunction parse(src, options = {}) {\n    const parser = new Parser(src, options);\n    return parser.parse();\n}\nexports.parse = parse;\n"],"names":["require$$0","parser"],"mappings":"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","x_google_ignoreList":[0]}