aontu 0.29.0 → 0.30.2

package/dist/hints.js

@@ -0,0 +1,84 @@
+"use strict";
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hints = void 0;
+/**
+ * Error code hints for Aontu unification errors.
+ *
+ * Each key is an error code that can be passed to makeNilErr.
+ * Each value is a human-readable explanation of what the error means.
+ */
+const hints = {
+    scalar_value: 'Literal scalar values of the same kind can only unify if they are\n' +
+        'exactly equal.' +
+        '\n \nExamples:\n' +
+        '  1 & 1   -> 1    # Does unify (equal Integers);\n' +
+        '  a & a   -> a    # Does unify (equal Strings);\n' +
+        '  1 & 2   -> nil  # Does not unify (unequal Integers);\n' +
+        '  1 & 1.0 -> nil  # Does not unify (kinds: Integer & Number).',
+    scalar_kind: 'Literal scalar values of different kinds cannot unify.' +
+        '\n \nExamples:\n' +
+        '  1 & 1   -> 1    # Does unify (equal Integers);\n' +
+        '  1 & a   -> nil  # Does not unify (Kinds: Integer & String);\n' +
+        '  1 & 1.0 -> nil  # Does not unify (kinds: Integer & Number).',
+    nil_gen: 'The nil value was present after unification, and nil cannot be\n' +
+        'generated because nil is not a literal value.',
+    no_gen: 'This value was present after unification, and cannot be generated\n' +
+        'because it is not a literal value.',
+    // TODO: extend errors to have details so we can name the key
+    mapval_required: 'This map value is required.',
+    mapval_no_gen: 'This value was present after unification, and cannot be generated\n' +
+        'because it is not a literal value.',
+    listval_required: 'This list element is required.',
+    listval_no_gen: 'This list element was present after unification, and cannot be generated\n' +
+        'because it is not a literal value.',
+    unknown_function: 'This function name is not recognized.',
+    literal_nil: 'A literal nil cannot unify with any other value.',
+    // Parsing errors
+    'parse_bad_src': 'Invalid source provided for parsing. The source must be a non-empty string.',
+    // Unification errors
+    'unify_no_src': 'No source provided for unification. Cannot unify without source values.',
+    'unify_no_res': 'Unification produced no result. The values could not be unified.',
+    'unite': 'Failed to unite two values. The values are incompatible and cannot be unified.',
+    'cycle': 'Circular reference detected during unification. The unification process encountered a cycle.',
+    'internal': 'Internal error during unification. This indicates an unexpected error in the unification process.',
+    // Type mismatch errors
+    'scalar-type': 'Scalar type mismatch. The scalar types are incompatible.',
+    'no-scalar-unify': 'Cannot unify scalar values. The scalar values have incompatible types.',
+    'not-scalar-type': 'Expected a scalar type but got a non-scalar type.',
+    'map': 'Type mismatch: expected a map value but got a different type.',
+    'list': 'Type mismatch: expected a list value but got a different type.',
+    // Argument errors
+    'arg': 'Missing required argument. A function requires an argument but none was provided.',
+    'invalid-arg': 'Invalid argument provided. The argument does not match the expected type or format.',
+    'no_first_arg': 'Missing first argument. The function requires a first argument but none was provided.',
+    // Variable errors
+    'unknown_var': 'Unknown variable reference. The variable has not been defined.',
+    'invalid_var_kind': 'Invalid variable kind. The variable type does not match the expected kind.',
+    // Path and reference errors
+    path_cycle: 'Path cycle detected. The path contains a circular reference.',
+    'ref': 'Reference resolution failed. Unable to resolve the reference to a value.',
+    // Closure and state errors
+    'closed': 'Cannot add to closed structure. The map or list is closed and does not accept new keys/elements.',
+    'required_listelem': 'Required list element is missing. A non-optional list element has no value.',
+    // Junction errors (disjunction/conjection)
+    '|:empty': 'Empty disjunction. The disjunction has no valid alternatives.',
+    '|:empty-dist': 'Empty disjunction distribution. All alternatives in the disjunction are invalid.',
+    // Function errors (dynamic patterns)
+    'func': 'Function operation failed. See the specific function name for details.',
+    'make': 'Failed to create a new value. The make operation could not construct the value.',
+    'resolve': 'Failed to resolve a value. The resolution process could not find or compute the value.',
+    'operate': 'Operation failed. The operation could not be performed on the given values.',
+    // Operator errors (dynamic patterns)
+    'op': 'Operator operation failed. See the specific operator name for details.',
+    // Close operation
+    'close': 'Failed to close structure. The structure could not be closed.',
+    // Dynamic patterns (these serve as prefixes)
+    'func:': 'Function error: ',
+    'op:': 'Operator error: ',
+    'var[': 'Variable type error: ',
+    'ref[': 'Reference error: ',
+    'op[': 'Operator value error: ',
+};
+exports.hints = hints;
+//# sourceMappingURL=hints.js.map

package/dist/hints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hints.js","sourceRoot":"","sources":["../src/hints.ts"],"names":[],"mappings":";AAAA,oDAAoD;;;AAEpD;;;;;GAKG;AAEH,MAAM,KAAK,GAA2B;IAEpC,YAAY,EACV,qEAAqE;QACrE,gBAAgB;QAChB,kBAAkB;QAClB,oDAAoD;QACpD,mDAAmD;QACnD,0DAA0D;QAC1D,+DAA+D;IAEjE,WAAW,EACT,wDAAwD;QACxD,kBAAkB;QAClB,oDAAoD;QACpD,iEAAiE;QACjE,+DAA+D;IAEjE,OAAO,EACL,kEAAkE;QAClE,+CAA+C;IAEjD,MAAM,EACJ,qEAAqE;QACrE,oCAAoC;IAGtC,6DAA6D;IAC7D,eAAe,EAAE,6BAA6B;IAE9C,aAAa,EACX,qEAAqE;QACrE,oCAAoC;IAEtC,gBAAgB,EAAE,gCAAgC;IAElD,cAAc,EACZ,4EAA4E;QAC5E,oCAAoC;IAEtC,gBAAgB,EACd,uCAAuC;IAEzC,WAAW,EACT,kDAAkD;IAGpD,iBAAiB;IACjB,eAAe,EAAE,6EAA6E;IAE9F,qBAAqB;IACrB,cAAc,EAAE,yEAAyE;IACzF,cAAc,EAAE,kEAAkE;IAClF,OAAO,EAAE,gFAAgF;IACzF,OAAO,EAAE,8FAA8F;IACvG,UAAU,EAAE,mGAAmG;IAE/G,uBAAuB;IAEvB,aAAa,EAAE,0DAA0D;IACzE,iBAAiB,EAAE,wEAAwE;IAC3F,iBAAiB,EAAE,mDAAmD;IACtE,KAAK,EAAE,+DAA+D;IACtE,MAAM,EAAE,gEAAgE;IAExE,kBAAkB;IAClB,KAAK,EAAE,mFAAmF;IAC1F,aAAa,EAAE,qFAAqF;IACpG,cAAc,EAAE,uFAAuF;IAEvG,kBAAkB;IAClB,aAAa,EAAE,gEAAgE;IAC/E,kBAAkB,EAAE,4EAA4E;IAEhG,4BAA4B;IAC5B,UAAU,EAAE,8DAA8D;IAC1E,KAAK,EAAE,0EAA0E;IAEjF,2BAA2B;IAC3B,QAAQ,EAAE,kGAAkG;IAC5G,mBAAmB,EAAE,6EAA6E;IAElG,2CAA2C;IAC3C,SAAS,EAAE,+DAA+D;IAC1E,cAAc,EAAE,kFAAkF;IAElG,qCAAqC;IACrC,MAAM,EAAE,wEAAwE;IAChF,MAAM,EAAE,iFAAiF;IACzF,SAAS,EAAE,wFAAwF;IACnG,SAAS,EAAE,6EAA6E;IAExF,qCAAqC;IACrC,IAAI,EAAE,wEAAwE;IAE9E,kBAAkB;IAClB,OAAO,EAAE,+DAA+D;IAExE,6CAA6C;IAC7C,OAAO,EAAE,kBAAkB;IAC3B,KAAK,EAAE,kBAAkB;IACzB,MAAM,EAAE,uBAAuB;IAC/B,MAAM,EAAE,mBAAmB;IAC3B,KAAK,EAAE,wBAAwB;CAChC,CAAA;AAIC,sBAAK"}

package/dist/lang.d.ts

@@ -0,0 +1,11 @@
+import { Jsonic } from 'jsonic';
+import type { Val, AontuOptions } from './type';
+import { Site } from './site';
+declare class Lang {
+    jsonic: Jsonic;
+    opts: AontuOptions;
+    idcount: number | undefined;
+    constructor(options?: Partial<AontuOptions>);
+    parse(src: string, opts?: Partial<AontuOptions>): Val;
+}
+export { Lang, Site, };

package/dist/lang.js

@@ -0,0 +1,569 @@
+"use strict";
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Site = exports.Lang = void 0;
+// import { performance } from 'node:perf_hooks'
+const jsonic_1 = require("jsonic");
+const debug_1 = require("jsonic/debug");
+const multisource_1 = require("@jsonic/multisource");
+const file_1 = require("@jsonic/multisource/resolver/file");
+const pkg_1 = require("@jsonic/multisource/resolver/pkg");
+const mem_1 = require("@jsonic/multisource/resolver/mem");
+const expr_1 = require("@jsonic/expr");
+const path_1 = require("@jsonic/path");
+const type_1 = require("./type");
+const site_1 = require("./site");
+Object.defineProperty(exports, "Site", { enumerable: true, get: function () { return site_1.Site; } });
+const top_1 = require("./val/top");
+const ScalarKindVal_1 = require("./val/ScalarKindVal");
+const BooleanVal_1 = require("./val/BooleanVal");
+const ConjunctVal_1 = require("./val/ConjunctVal");
+const DisjunctVal_1 = require("./val/DisjunctVal");
+const IntegerVal_1 = require("./val/IntegerVal");
+const ListVal_1 = require("./val/ListVal");
+const MapVal_1 = require("./val/MapVal");
+const NilVal_1 = require("./val/NilVal");
+const NullVal_1 = require("./val/NullVal");
+const NumberVal_1 = require("./val/NumberVal");
+const PrefVal_1 = require("./val/PrefVal");
+const RefVal_1 = require("./val/RefVal");
+const StringVal_1 = require("./val/StringVal");
+const VarVal_1 = require("./val/VarVal");
+const PlusOpVal_1 = require("./val/PlusOpVal");
+const UpperFuncVal_1 = require("./val/UpperFuncVal");
+const LowerFuncVal_1 = require("./val/LowerFuncVal");
+const CopyFuncVal_1 = require("./val/CopyFuncVal");
+const KeyFuncVal_1 = require("./val/KeyFuncVal");
+const TypeFuncVal_1 = require("./val/TypeFuncVal");
+const HideFuncVal_1 = require("./val/HideFuncVal");
+const MoveFuncVal_1 = require("./val/MoveFuncVal");
+const PathFuncVal_1 = require("./val/PathFuncVal");
+const PrefFuncVal_1 = require("./val/PrefFuncVal");
+const CloseFuncVal_1 = require("./val/CloseFuncVal");
+const OpenFuncVal_1 = require("./val/OpenFuncVal");
+const SuperFuncVal_1 = require("./val/SuperFuncVal");
+let AontuJsonic = function AontuLang(jsonic) {
+    jsonic.use(path_1.Path);
+    // TODO: refactor Val constructor
+    // let addsite = (v: Val, p: string[]) => (v.path = [...(p || [])], v)
+    let addsite = (v, r, ctx) => {
+        v.site.row = null == r.o0 ? -1 : r.o0.rI;
+        v.site.col = null == r.o0 ? -1 : r.o0.cI;
+        v.site.url = ctx.meta.multisource ? ctx.meta.multisource.path : '';
+        v.path = r.k ? [...(r.k.path || [])] : [];
+        return v;
+    };
+    jsonic.options({
+        hint: {
+            unknown: `
+Since the error is unknown, this is probably a bug. Please consider
+posting a github issue - thanks!
+
+Code: {code}, Details: 
+{details}`,
+            unexpected: `
+The character(s) {src} were not expected at this point as they do not
+match the expected syntax. Use the # character to comment out lines to
+help isolate the syntax error.`,
+        },
+        errmsg: {
+            name: 'aontu',
+            suffix: false,
+        },
+        fixed: {
+            token: {
+                '#QM': '?'
+            },
+        },
+        value: {
+            def: {
+                // NOTE: specify with functions as jsonic/deep will
+                // remove class prototype as options are assumed plain
+                // (except for functions).
+                // TODO: jsonic should be able to pass context into these
+                'string': {
+                    val: (r, ctx) => addsite(new ScalarKindVal_1.ScalarKindVal({ peg: String }), r, ctx)
+                },
+                'number': {
+                    val: (r, ctx) => addsite(new ScalarKindVal_1.ScalarKindVal({ peg: Number }), r, ctx)
+                },
+                'integer': {
+                    val: (r, ctx) => addsite(new ScalarKindVal_1.ScalarKindVal({ peg: ScalarKindVal_1.Integer }), r, ctx)
+                },
+                'boolean': {
+                    val: (r, ctx) => addsite(new ScalarKindVal_1.ScalarKindVal({ peg: Boolean }), r, ctx)
+                },
+                'nil': {
+                    val: (r, ctx) => addsite(new NilVal_1.NilVal({ why: 'literal_nil' }), r, ctx)
+                },
+                // TODO: FIX: need a TOP instance to hold path
+                'top': { val: () => (0, top_1.top)() },
+            }
+        },
+        map: {
+            merge: (prev, curr, _r, ctx) => {
+                let pval = prev;
+                let cval = curr;
+                if (pval?.isVal && cval?.isVal) {
+                    // TODO: test multi element conjuncts work
+                    if (pval.isConjunct && cval.isConjunct) {
+                        pval.append(cval);
+                        return pval;
+                    }
+                    else if (pval.isConjunct) {
+                        pval.append(cval);
+                        return pval;
+                    }
+                    else {
+                        return addsite(new ConjunctVal_1.ConjunctVal({ peg: [pval, cval] }), prev, ctx);
+                    }
+                }
+                // Handle defered conjuncts, where MapVal does not yet
+                // exist, by creating ConjunctVal later.
+                else {
+                    prev.___merge = (prev.___merge || []);
+                    prev.___merge.push(curr);
+                    return prev;
+                }
+            }
+        }
+    });
+    const funcMap = {
+        upper: UpperFuncVal_1.UpperFuncVal,
+        lower: LowerFuncVal_1.LowerFuncVal,
+        copy: CopyFuncVal_1.CopyFuncVal,
+        key: KeyFuncVal_1.KeyFuncVal,
+        type: TypeFuncVal_1.TypeFuncVal,
+        hide: HideFuncVal_1.HideFuncVal,
+        move: MoveFuncVal_1.MoveFuncVal,
+        path: PathFuncVal_1.PathFuncVal,
+        pref: PrefFuncVal_1.PrefFuncVal,
+        close: CloseFuncVal_1.CloseFuncVal,
+        open: OpenFuncVal_1.OpenFuncVal,
+        super: SuperFuncVal_1.SuperFuncVal,
+    };
+    let opmap = {
+        'conjunct-infix': (r, ctx, _op, terms) => addsite(new ConjunctVal_1.ConjunctVal({ peg: terms }), r, ctx),
+        'disjunct-infix': (r, ctx, _op, terms) => addsite(new DisjunctVal_1.DisjunctVal({ peg: terms }), r, ctx),
+        'dot-prefix': (r, ctx, _op, terms) => {
+            return addsite(new RefVal_1.RefVal({ peg: terms, prefix: true }), r, ctx);
+        },
+        'dot-infix': (r, ctx, _op, terms) => {
+            // // console.log('DOT-INFIX-OP', terms)
+            return addsite(new RefVal_1.RefVal({ peg: terms }), r, ctx);
+        },
+        'star-prefix': (r, ctx, _op, terms) => addsite(new PrefVal_1.PrefVal({ peg: terms[0] }), r, ctx),
+        'dollar-prefix': (r, ctx, _op, terms) => {
+            // $.a.b absolute path
+            if (terms[0] instanceof RefVal_1.RefVal) {
+                terms[0].absolute = true;
+                return terms[0];
+            }
+            return addsite(new VarVal_1.VarVal({ peg: terms[0] }), r, ctx);
+        },
+        'plus-infix': (r, ctx, _op, terms) => {
+            return addsite(new PlusOpVal_1.PlusOpVal({ peg: [terms[0], terms[1]] }), r, ctx);
+        },
+        'negative-prefix': (r, ctx, _op, terms) => {
+            let val = terms[0];
+            val.peg = -1 * val.peg;
+            return addsite(val, r, ctx);
+        },
+        'positive-prefix': (r, ctx, _op, terms) => {
+            let val = terms[0];
+            return addsite(val, r, ctx);
+        },
+        'func-paren': (r, ctx, _op, terms) => {
+            let val = terms[1];
+            const fname = terms[0];
+            if ('' !== fname) {
+                const funcval = funcMap[fname];
+                const args = terms.slice(1);
+                val = null == funcval ?
+                    new NilVal_1.NilVal({ why: 'unknown_function' }) :
+                    new funcval({
+                        peg: args
+                    });
+            }
+            const out = addsite(val, r, ctx);
+            return out;
+        },
+    };
+    jsonic
+        .use(expr_1.Expr, {
+        op: {
+            // disjunct < conjunct: c & b | a -> (c & b) | a
+            'conjunct': {
+                infix: true, src: '&', left: 16_000_000, right: 17_000_000
+            },
+            'disjunct': {
+                infix: true, src: '|', left: 14_000_000, right: 15_000_000
+            },
+            'plus-infix': {
+                src: '+',
+                infix: true,
+                left: 20_000_000,
+                right: 21_000_000,
+            },
+            'dollar-prefix': {
+                src: '$',
+                prefix: true,
+                right: 31_000_000,
+            },
+            'dot-infix': {
+                src: '.',
+                infix: true,
+                left: 25_000_000,
+                right: 24_000_000,
+            },
+            'dot-prefix': {
+                src: '.',
+                prefix: true,
+                right: 24_000_000,
+            },
+            'star': {
+                src: '*',
+                prefix: true,
+                right: 24_000_000,
+            },
+            'func': {
+                paren: true,
+                preval: {
+                    active: true,
+                    // allow: ['floor'], //Object.keys(funcMap)
+                },
+                osrc: '(',
+                csrc: ')',
+            },
+            plain: null,
+            addition: null,
+            subtraction: null,
+            multiplication: null,
+            division: null,
+            remainder: null,
+        },
+        evaluate: (r, ctx, op, terms) => {
+            // // console.log('EVAL-START', r.u)
+            if ('func-paren' === op.name
+                // && !r.parent.prev?.u?.paren_preval
+                && !r.u?.paren_preval) {
+                // terms = [new StringVal({ peg: '' }), ...terms]
+                terms = ['', ...terms];
+            }
+            let val = opmap[op.name](r, ctx, op, terms);
+            // // console.log('EVAL', terms, '->', val)
+            return val;
+        }
+    });
+    const CJ = jsonic.token['#E&'];
+    const CL = jsonic.token.CL;
+    const ST = jsonic.token.ST;
+    const TX = jsonic.token.TX;
+    const NR = jsonic.token.NR;
+    const QM = jsonic.token.QM;
+    const OPTKEY = [TX, ST, NR];
+    jsonic.rule('val', (rs) => {
+        rs
+            .open([
+            { s: [CJ, CL], p: 'map', b: 2, n: { pk: 1 }, g: 'spread' },
+            {
+                s: [OPTKEY, QM],
+                c: (r) => 0 == r.d,
+                p: 'map',
+                b: 2,
+                g: 'pair,jsonic,top,aontu-optional',
+            },
+            {
+                s: [OPTKEY, QM],
+                p: 'map',
+                b: 2,
+                n: { pk: 1 },
+                g: 'pair,jsonic,top,dive,aontu-optional',
+            },
+        ])
+            .bc((r, ctx) => {
+            let valnode = r.node;
+            let valtype = typeof valnode;
+            if ('string' === valtype) {
+                valnode = addsite(new StringVal_1.StringVal({ peg: r.node }), r, ctx);
+            }
+            else if ('number' === valtype) {
+                // 1.0 in source is *not* an integer
+                if (Number.isInteger(r.node) && !r.o0.src.includes('.')) {
+                    valnode = addsite(new IntegerVal_1.IntegerVal({ peg: r.node, src: r.o0.src }), r, ctx);
+                }
+                else {
+                    valnode = addsite(new NumberVal_1.NumberVal({ peg: r.node, src: r.o0.src }), r, ctx);
+                }
+            }
+            else if ('boolean' === valtype) {
+                valnode = addsite(new BooleanVal_1.BooleanVal({ peg: r.node }), r, ctx);
+            }
+            else if (null === valnode) {
+                valnode = addsite(new NullVal_1.NullVal({ peg: r.node }), r, ctx);
+            }
+            if (null != valnode && 'object' === typeof valnode && valnode.site) {
+                let st = r.o0;
+                valnode.site.row = st.rI;
+                valnode.site.col = st.cI;
+                valnode.site.url = ctx.meta.multisource && ctx.meta.multisource.path;
+            }
+            // else { ERROR? }
+            r.node = valnode;
+            return undefined;
+        })
+            .close([{ s: [CJ, CL], b: 2, g: 'spread,json,more' }]);
+        return rs;
+    });
+    jsonic.rule('map', (rs) => {
+        rs
+            .open([
+            { s: [CJ, CL], p: 'pair', b: 2, g: 'spread' },
+            { s: [OPTKEY, QM], p: 'pair', b: 2, g: 'pair,list,val,imp,jsonic,aontu-optional' },
+        ])
+            .bc((r, ctx) => {
+            const optionalKeys = r.u.aontu_optional_keys ?? [];
+            let mo = r.node;
+            //  Handle defered conjuncts, e.g. `{x:1 @"foo"}`
+            if (mo.___merge) {
+                let mop = { ...mo };
+                delete mop.___merge;
+                // TODO: needs addpath?
+                let mopv = new MapVal_1.MapVal({ peg: mop });
+                mopv.optionalKeys = optionalKeys;
+                r.node =
+                    addsite(new ConjunctVal_1.ConjunctVal({ peg: [mopv, ...mo.___merge] }), r, ctx);
+            }
+            else {
+                r.node = addsite(new MapVal_1.MapVal({ peg: mo }), r, ctx);
+                r.node.optionalKeys = optionalKeys;
+            }
+            return undefined;
+        })
+            .close([{ s: [CJ, CL], b: 2, g: 'spread,json,more' }]);
+        return rs;
+    });
+    jsonic.rule('list', (rs) => {
+        rs
+            // .open([{ s: [CJ, CL], p: 'pair', b: 2, g: 'spread' }])
+            .bc((r, ctx) => {
+            const optionalKeys = r.u.aontu_optional_keys ?? [];
+            let ao = r.node;
+            if (ao.___merge) {
+                let aop = [...ao];
+                delete aop.___merge;
+                // TODO: needs addpath?
+                let aopv = new ListVal_1.ListVal({ peg: aop });
+                aopv.optionalKeys = optionalKeys;
+                r.node =
+                    addsite(new ConjunctVal_1.ConjunctVal({ peg: [aopv, ...ao.___merge] }), r, ctx);
+            }
+            else {
+                r.node = addsite(new ListVal_1.ListVal({ peg: ao }), r, ctx);
+                r.node.optionalKeys = optionalKeys;
+            }
+            return undefined;
+        });
+        // .close([{ s: [CJ, CL], b: 2, g: 'spread,json,more' }])
+        return rs;
+    });
+    // TODO: copied from jsonic grammar
+    // jsonic should provide a way to export this
+    const pairkey = (r) => {
+        // Get key string value from first matching token of `Open` state.
+        const key_token = r.o0;
+        const key = ST === key_token.tin || TX === key_token.tin
+            ? key_token.val // Was text
+            : key_token.src; // Was number, use original text
+        r.u.key = key;
+    };
+    jsonic.rule('pair', (rs) => {
+        rs
+            .open([
+            {
+                s: [CJ, CL], p: 'val',
+                u: { spread: true },
+                g: 'spread'
+            },
+            {
+                s: [OPTKEY, QM], b: 1, r: 'pair', u: { aontu_optional: true },
+                g: 'aontu-optional-key'
+            },
+            {
+                s: [QM, CL],
+                c: (r) => r.prev.u.aontu_optional,
+                p: 'val',
+                u: { pair: true },
+                a: (r) => {
+                    pairkey(r.prev);
+                    r.u.key = r.prev.u.key;
+                    r.parent.u.aontu_optional_keys = (r.parent.u.aontu_optional_keys || []);
+                    r.parent.u.aontu_optional_keys.push('' + r.u.key);
+                },
+                g: 'aontu-optional-pair'
+            }
+        ])
+            // NOTE: manually adjust path - @jsonic/path ignores as not pair:true
+            .ao((r) => {
+            if (0 < r.d && r.u.spread) {
+                r.child.k.path = [...r.k.path, '&'];
+                r.child.k.key = '&';
+            }
+        })
+            .bc((rule) => {
+            // TRAVERSE PARENTS TO GET PATH
+            if (rule.u.spread) {
+                rule.node[type_1.SPREAD] =
+                    (rule.node[type_1.SPREAD] || { o: rule.o0.src, v: [] });
+                rule.node[type_1.SPREAD].v.push(rule.child.node);
+            }
+            return undefined;
+        })
+            .close([
+            { s: [CJ, CL], c: (r) => r.lte('dmap', 1), r: 'pair', b: 2, g: 'spread,json,pair' },
+            { s: [CJ, CL], b: 2, g: 'spread,json,more' }
+        ]);
+        return rs;
+    });
+    jsonic.rule('elem', (rs) => {
+        rs
+            .open([
+            {
+                s: [CJ, CL],
+                p: 'val',
+                n: { pk: 1, dmap: 1 },
+                u: { spread: true, done: true, list: true },
+                g: 'spread'
+            },
+            {
+                s: [OPTKEY, QM], b: 1, r: 'elem', u: { aontu_optional: true },
+                g: 'aontu-optional-key-elem'
+            },
+            {
+                s: [QM, CL],
+                c: (r) => r.prev.u.aontu_optional,
+                p: 'val',
+                u: { spread: true, done: true, list: true, pair: true },
+                a: (r) => {
+                    pairkey(r.prev);
+                    r.u.key = r.prev.u.key;
+                    r.parent.u.aontu_optional_keys = (r.parent.u.aontu_optional_keys || []);
+                    r.parent.u.aontu_optional_keys.push('' + r.u.key);
+                },
+                g: 'aontu-optional-elem'
+            }
+        ])
+            .bc((rule) => {
+            // TRAVERSE PARENTS TO GET PATH
+            if (rule.u.spread) {
+                rule.node[type_1.SPREAD] =
+                    (rule.node[type_1.SPREAD] || { o: rule.o0.src, v: [] });
+                rule.node[type_1.SPREAD].v.push(rule.child.node);
+            }
+            return undefined;
+        })
+            .close([{ s: [CJ, CL], r: 'elem', b: 2, g: 'spread,json,more' }]);
+        return rs;
+    });
+};
+function makeModelResolver(options) {
+    const useRequire = options.require || require;
+    let memResolver = (0, mem_1.makeMemResolver)({
+        ...(options.resolver?.mem || {})
+    });
+    // TODO: make this consistent with other resolvers
+    let fileResolver = (0, file_1.makeFileResolver)((spec) => {
+        return 'string' === typeof spec ? spec : spec?.peg;
+    });
+    let pkgResolver = (0, pkg_1.makePkgResolver)({
+        require: useRequire,
+        ...(options.resolver?.pkg || {})
+    });
+    return function ModelResolver(spec, popts, rule, ctx, jsonic) {
+        let path = 'string' === typeof spec ? spec : spec?.peg;
+        let search = [];
+        let res = memResolver(path, popts, rule, ctx, jsonic);
+        res.path = path;
+        if (res.found) {
+            return res;
+        }
+        search = search.concat(res.search);
+        res = fileResolver(path, popts, rule, ctx, jsonic);
+        res.path = path;
+        if (res.found) {
+            return res;
+        }
+        search = search.concat(res.search);
+        res = pkgResolver(path, popts, rule, ctx, jsonic);
+        res.path = path;
+        if (res.found) {
+            return res;
+        }
+        res.search = search.concat(res.search);
+        return res;
+    };
+}
+class Lang {
+    constructor(options) {
+        // const start = performance.now()
+        this.opts = Object.assign((0, type_1.DEFAULT_OPTS)(), options);
+        const modelResolver = makeModelResolver(this.opts);
+        this.jsonic = jsonic_1.Jsonic.make();
+        if (this.opts.debug) {
+            this.jsonic.use(debug_1.Debug, {
+                trace: this.opts.trace
+            });
+        }
+        this.jsonic
+            .use(AontuJsonic)
+            .use(multisource_1.MultiSource, {
+            // resolver: options?.resolver || includeFileResolver
+            resolver: options?.resolver || modelResolver
+        });
+        // if (false === (global as any).aontu_warm) {
+        //   (global as any).aontu.time.langctor.push(performance.now() - start)
+        // }
+    }
+    parse(src, opts) {
+        // const start = performance.now()
+        // JSONIC-UPDATE - check meta
+        let jm = {
+            fs: opts?.fs,
+            fileName: opts?.path ?? this.opts.path,
+            multisource: {
+                path: opts?.path ?? this.opts.path,
+                deps: (opts && opts.deps) || undefined
+            }
+        };
+        if (null != opts?.idcount) {
+            this.idcount = opts.idcount;
+        }
+        // Pass through Jsonic debug log value
+        if (opts && null != opts.log && Number.isInteger(opts.log)) {
+            jm.log = opts.log;
+        }
+        // jm.log = -1
+        let val;
+        try {
+            val = this.jsonic(src, jm);
+        }
+        catch (e) {
+            if (e instanceof jsonic_1.JsonicError || 'JsonicError' === e.constructor.name) {
+                val = new NilVal_1.NilVal({
+                    why: 'parse',
+                    err: new NilVal_1.NilVal({
+                        why: 'syntax',
+                        msg: e.message,
+                        err: e,
+                    })
+                });
+            }
+            else {
+                throw e;
+            }
+        }
+        return val;
+    }
+}
+exports.Lang = Lang;
+//# sourceMappingURL=lang.js.map