@scriptc/compiler 0.2.3 → 0.2.5

package/dist/frontend/lowering/collection-ingestion.js

@@ -2,27 +2,42 @@ import * as ts from "../ts7/adapter.js";
 import { InternalCompilerError } from "../../errors.js";
 import { typeKey } from "../type-mapper.js";
 import { boolLit, countedFor, numLit, strLit, varRef } from "../../ir/build.js";
-import { BOOL, CAUGHT, DYN, F64, VOID, typeEquals } from "../../ir/ir.js";
+import { BOOL, CAUGHT, DYN, F64, VOID, typeEquals, } from "../../ir/ir.js";
 import { arrayValueStore } from "./array-values.js";
+import { iteratorCanStep, iteratorValue } from "./iterator-consumption.js";
 import { newFnCtx } from "./lowerer.js";
 function entryType(lowerer, key, value) {
-    return { kind: "record", shapeId: lowerer.shapes.intern([{ name: "0", type: key }, { name: "1", type: value }], true) };
+    return {
+        kind: "record",
+        shapeId: lowerer.shapes.intern([
+            { name: "0", type: key },
+            { name: "1", type: value },
+        ], true),
+    };
 }
 /** Only builtin collection views can bypass iterator dispatch. Stored
  * cursors keep the protocol path, including overridden next/return methods. */
 export function collectionInput(lowerer, expression) {
     while (ts.isParenthesizedExpression(expression))
         expression = expression.expression;
-    if (ts.isCallExpression(expression) && !expression.questionDotToken && expression.arguments.length === 0 &&
-        ts.isPropertyAccessExpression(expression.expression) && !expression.expression.questionDotToken) {
+    if (ts.isCallExpression(expression) &&
+        !expression.questionDotToken &&
+        expression.arguments.length === 0 &&
+        ts.isPropertyAccessExpression(expression.expression) &&
+        !expression.expression.questionDotToken) {
         const access = expression.expression;
         const selection = access.name.text;
-        if ((selection === "keys" || selection === "values" || selection === "entries") && lowerer.isStdlibMember(access)) {
+        if ((selection === "keys" || selection === "values" || selection === "entries") &&
+            lowerer.isStdlibMember(access)) {
             const collection = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
             if (collection?.kind === "map" || collection?.kind === "set") {
                 const key = collection.kind === "map" ? collection.key : collection.elem;
                 const value = collection.kind === "map" ? collection.value : collection.elem;
-                const element = selection === "entries" ? entryType(lowerer, key, value) : selection === "keys" ? key : value;
+                const element = selection === "entries"
+                    ? entryType(lowerer, key, value)
+                    : selection === "keys"
+                        ? key
+                        : value;
                 return { source: access.expression, element, collection, selection, access };
             }
         }
@@ -30,11 +45,18 @@ export function collectionInput(lowerer, expression) {
     const type = lowerer.typeOf(expression);
     const mapped = lowerer.mapTypeOf(type);
     if (mapped?.kind === "map")
-        return { source: expression, collection: mapped, selection: "entries", element: entryType(lowerer, mapped.key, mapped.value) };
+        return {
+            source: expression,
+            collection: mapped,
+            selection: "entries",
+            element: entryType(lowerer, mapped.key, mapped.value),
+        };
     if (mapped?.kind === "set")
         return { source: expression, collection: mapped, selection: "values", element: mapped.elem };
     const symbol = type.getSymbol();
-    if (!symbol || (symbol.name !== "MapIterator" && symbol.name !== "SetIterator") || !lowerer.isStdlibSymbol(symbol))
+    if (!symbol ||
+        (symbol.name !== "MapIterator" && symbol.name !== "SetIterator") ||
+        !lowerer.isStdlibSymbol(symbol))
         return null;
     const argument = lowerer.checker.getTypeArguments(type)[0];
     const element = argument ? lowerer.mapTypeOf(argument) : null;
@@ -44,17 +66,21 @@ export function collectionDestinationMatches(lowerer, input, destination) {
     if (destination.kind !== "map")
         return typeEquals(input.element, destination.elem);
     const shape = input.element.kind === "record" ? lowerer.shapes.get(input.element.shapeId) : null;
-    const key = shape?.fields.find(field => field.name === "0");
-    const value = shape?.fields.find(field => field.name === "1");
-    return !!shape?.tuple && shape.fields.length === 2 &&
-        !!key && !!value && typeEquals(key.type, destination.key) && typeEquals(value.type, destination.value);
+    const key = shape?.fields.find((field) => field.name === "0");
+    const value = shape?.fields.find((field) => field.name === "1");
+    return (!!shape?.tuple &&
+        shape.fields.length === 2 &&
+        !!key &&
+        !!value &&
+        typeEquals(key.type, destination.key) &&
+        typeEquals(value.type, destination.value));
 }
 export function lowerCollectionInput(lowerer, input) {
     const value = lowerer.lowerExpr(input.source);
     if (!input.collection)
         return value.type.kind === "dyn" ? value : null;
     const source = input.access
-        ? lowerer.runtimeOptionalPropertyReceiver(input.source, value, input.collection, input.selection) ?? value
+        ? (lowerer.runtimeOptionalPropertyReceiver(input.source, value, input.collection, input.selection) ?? value)
         : value;
     return typeEquals(source.type, input.collection) ? source : null;
 }
@@ -62,8 +88,51 @@ export function lowerCollectionInput(lowerer, input) {
  * traversal; stored cursors acquire next once and retain protocol behavior.
  * Both paths retain element identity and clean up on callback exceptions. */
 export function ingestCollection(lowerer, input, source, destination, loc, mapper) {
-    if (!mapper && destination.kind === "array" && input.collection?.kind === "set" && input.selection !== "entries") {
-        return { kind: "setIntrinsic", method: "toArray", receiver: source, args: [], type: destination, loc };
+    if (!mapper &&
+        input.collection &&
+        destination.kind === "map" &&
+        input.selection === "entries" &&
+        typeEquals(input.collection, destination)) {
+        return {
+            kind: "mapIntrinsic",
+            method: "clone",
+            receiver: source,
+            args: [],
+            type: destination,
+            loc,
+        };
+    }
+    if (!mapper && input.collection && destination.kind === "set" && input.selection !== "entries") {
+        return input.collection.kind === "set"
+            ? {
+                kind: "setIntrinsic",
+                method: "clone",
+                receiver: source,
+                args: [],
+                type: destination,
+                loc,
+            }
+            : {
+                kind: "mapIntrinsic",
+                method: input.selection === "keys" ? "keySet" : "valueSet",
+                receiver: source,
+                args: [],
+                type: destination,
+                loc,
+            };
+    }
+    if (!mapper &&
+        destination.kind === "array" &&
+        input.collection?.kind === "set" &&
+        input.selection !== "entries") {
+        return {
+            kind: "setIntrinsic",
+            method: "toArray",
+            receiver: source,
+            args: [],
+            type: destination,
+            loc,
+        };
     }
     const key = `ingest:${input.collection ? typeKey(input.collection) + ":" + input.selection : "cursor:" + typeKey(input.element)}:${typeKey(destination)}:${mapper ? typeKey(mapper.type) : "copy"}`;
     let name = lowerer.arrHofHelpers.get(key);
@@ -73,24 +142,54 @@ export function ingestCollection(lowerer, input, source, destination, loc, mappe
         const context = newFnCtx(false, null, null, destination);
         lowerer.fnStack.push(context);
         try {
-            const params = [{ localId: "source.0", name: "source", type: source.type },
-                ...(mapper ? [{ localId: "mapper.0", name: "mapper", type: mapper.type }] : [])];
-            const locals = params.map(param => ({ id: param.localId, name: param.name, type: param.type, mutable: false }));
+            const params = [
+                { localId: "source.0", name: "source", type: source.type },
+                ...(mapper ? [{ localId: "mapper.0", name: "mapper", type: mapper.type }] : []),
+            ];
+            const locals = params.map((param) => ({
+                id: param.localId,
+                name: param.name,
+                type: param.type,
+                mutable: false,
+            }));
             const out = varRef("out.0", destination, loc);
             const index = varRef("index.0", F64, loc);
             locals.push({ id: "out.0", name: "out", type: destination, mutable: false }, { id: "index.0", name: "index", type: F64, mutable: true });
-            const init = destination.kind === "array" ? { kind: "arrayLit", elems: [], type: destination, loc }
-                : destination.kind === "map" ? { kind: "mapNew", type: destination, loc } : { kind: "setNew", type: destination, loc };
+            const init = destination.kind === "array"
+                ? { kind: "arrayLit", elems: [], type: destination, loc }
+                : destination.kind === "map"
+                    ? { kind: "mapNew", type: destination, loc }
+                    : { kind: "setNew", type: destination, loc };
             const append = (value) => {
                 const inputLocal = mapper ? lowerer.declareHiddenLocal("%mappedValue", value.type) : null;
-                const prefix = inputLocal ? [{ kind: "varDecl", localId: inputLocal.id, init: value, loc }] : [];
-                const item = mapper ? { kind: "callValue", callee: varRef("mapper.0", mapper.type, loc),
-                    args: [varRef(inputLocal.id, value.type, loc), index].slice(0, mapper.type.params.length), type: mapper.type.ret, loc } : value;
+                const prefix = inputLocal
+                    ? [{ kind: "varDecl", localId: inputLocal.id, init: value, loc }]
+                    : [];
+                const item = mapper
+                    ? {
+                        kind: "callValue",
+                        callee: varRef("mapper.0", mapper.type, loc),
+                        args: [varRef(inputLocal.id, value.type, loc), index].slice(0, mapper.type.params.length),
+                        type: mapper.type.ret,
+                        loc,
+                    }
+                    : value;
                 let store;
                 if (destination.kind === "array")
                     store = arrayValueStore(lowerer, out, index, item, destination.elem, loc);
                 else if (destination.kind === "set")
-                    store = { kind: "exprStmt", expr: { kind: "setIntrinsic", method: "add", receiver: out, args: [item], type: VOID, loc }, loc };
+                    store = {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "setIntrinsic",
+                            method: "add",
+                            receiver: out,
+                            args: [item],
+                            type: VOID,
+                            loc,
+                        },
+                        loc,
+                    };
                 else {
                     if (item.type.kind === "dyn") {
                         // Map discards the entry wrapper. Preserve its members, but do
@@ -98,15 +197,37 @@ export function ingestCollection(lowerer, input, source, destination, loc, mappe
                         const pair = lowerer.declareHiddenLocal("%entry", DYN);
                         const key = lowerer.declareHiddenLocal("%entryKey", DYN);
                         const value = lowerer.declareHiddenLocal("%entryValue", DYN);
-                        const member = (field) => ({ kind: "dynKeyGet", value: varRef(pair.id, DYN, loc), key: strLit(field, loc), type: DYN, loc });
-                        const checked = (id, type) => type.kind === "dyn" ? varRef(id, DYN, loc)
+                        const member = (field) => ({
+                            kind: "dynKeyGet",
+                            value: varRef(pair.id, DYN, loc),
+                            key: strLit(field, loc),
+                            type: DYN,
+                            loc,
+                        });
+                        const checked = (id, type) => type.kind === "dyn"
+                            ? varRef(id, DYN, loc)
                             : { kind: "dynCheck", value: varRef(id, DYN, loc), preserveRefs: true, type, loc };
                         return [
-                            { kind: "varDecl", localId: pair.id, init: { kind: "libCall", fn: "dyn.mapSeedEntry", args: [item], type: DYN, loc }, loc },
+                            {
+                                kind: "varDecl",
+                                localId: pair.id,
+                                init: { kind: "libCall", fn: "dyn.mapSeedEntry", args: [item], type: DYN, loc },
+                                loc,
+                            },
                             { kind: "varDecl", localId: key.id, init: member("0"), loc },
                             { kind: "varDecl", localId: value.id, init: member("1"), loc },
-                            { kind: "exprStmt", expr: { kind: "mapIntrinsic", method: "set", receiver: out,
-                                    args: [checked(key.id, destination.key), checked(value.id, destination.value)], type: VOID, loc }, loc },
+                            {
+                                kind: "exprStmt",
+                                expr: {
+                                    kind: "mapIntrinsic",
+                                    method: "set",
+                                    receiver: out,
+                                    args: [checked(key.id, destination.key), checked(value.id, destination.value)],
+                                    type: VOID,
+                                    loc,
+                                },
+                                loc,
+                            },
                         ];
                     }
                     if (item.type.kind !== "record")
@@ -114,36 +235,86 @@ export function ingestCollection(lowerer, input, source, destination, loc, mappe
                     const shapeId = item.type.shapeId;
                     const local = lowerer.declareHiddenLocal("%entry", item.type);
                     const entry = varRef(local.id, item.type, loc);
-                    return [{ kind: "varDecl", localId: local.id, init: item, loc }, { kind: "exprStmt", expr: {
-                                kind: "mapIntrinsic", method: "set", receiver: out, args: [
-                                    { kind: "recordGet", obj: entry, shapeId, field: "0", type: destination.key, loc },
-                                    { kind: "recordGet", obj: entry, shapeId, field: "1", type: destination.value, loc },
-                                ], type: VOID, loc
-                            }, loc }];
+                    return [
+                        { kind: "varDecl", localId: local.id, init: item, loc },
+                        {
+                            kind: "exprStmt",
+                            expr: {
+                                kind: "mapIntrinsic",
+                                method: "set",
+                                receiver: out,
+                                args: [
+                                    {
+                                        kind: "recordGet",
+                                        obj: entry,
+                                        shapeId,
+                                        field: "0",
+                                        type: destination.key,
+                                        loc,
+                                    },
+                                    {
+                                        kind: "recordGet",
+                                        obj: entry,
+                                        shapeId,
+                                        field: "1",
+                                        type: destination.value,
+                                        loc,
+                                    },
+                                ],
+                                type: VOID,
+                                loc,
+                            },
+                            loc,
+                        },
+                    ];
                 }
-                return [...prefix, store, { kind: "assign", localId: "index.0", value: { kind: "bin", op: "+", left: index, right: numLit(1, loc), type: F64, loc }, loc }];
+                return [
+                    ...prefix,
+                    store,
+                    {
+                        kind: "assign",
+                        localId: "index.0",
+                        value: { kind: "bin", op: "+", left: index, right: numLit(1, loc), type: F64, loc },
+                        loc,
+                    },
+                ];
             };
             const sourceRef = varRef("source.0", source.type, loc);
             const consumption = input.collection
                 ? nativeConsumption(lowerer, input, sourceRef, destination, out, append, locals, loc)
                 : cursorConsumption(lowerer, sourceRef, destination.kind === "map" ? DYN : input.element, append, destination.kind !== "array", loc);
-            lowerer.liftedFns.push({ name, params, returnType: destination, locals: [...locals, ...context.locals], body: [
+            lowerer.liftedFns.push({
+                name,
+                params,
+                returnType: destination,
+                locals: [...locals, ...context.locals],
+                body: [
                     { kind: "varDecl", localId: "out.0", init, loc },
                     { kind: "varDecl", localId: "index.0", init: numLit(0, loc), loc },
                     ...consumption,
                     { kind: "return", value: out, loc },
-                ], loc });
+                ],
+                loc,
+            });
         }
         finally {
             lowerer.fnStack.pop();
         }
     }
-    return { kind: "call", callee: name, args: [source, ...(mapper ? [mapper] : [])], type: destination, loc };
+    return {
+        kind: "call",
+        callee: name,
+        args: [source, ...(mapper ? [mapper] : [])],
+        type: destination,
+        loc,
+    };
 }
 function nativeConsumption(lowerer, input, source, destination, out, append, locals, loc) {
     const collection = input.collection;
     const iter = (method, type) => {
-        const args = method === "iterKey" || method === "iterValue" || method === "iterLive" ? [varRef("i.0", F64, loc)] : [];
+        const args = method === "iterKey" || method === "iterValue" || method === "iterLive"
+            ? [varRef("i.0", F64, loc)]
+            : [];
         if (collection.kind === "map")
             return { kind: "mapIntrinsic", method, receiver: source, args, type, loc };
         if (method === "iterValue")
@@ -156,60 +327,181 @@ function nativeConsumption(lowerer, input, source, destination, out, append, loc
     if (destination.kind === "map" && input.selection === "entries" && collection.kind === "map") {
         // Consume entry fields directly instead of allocating a tuple that the
         // constructor immediately destructures and discards.
-        visit = [{ kind: "exprStmt", expr: { kind: "mapIntrinsic", method: "set", receiver: out, args: [key, value], type: VOID, loc }, loc }];
+        visit = [
+            {
+                kind: "exprStmt",
+                expr: {
+                    kind: "mapIntrinsic",
+                    method: "set",
+                    receiver: out,
+                    args: [key, value],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            },
+        ];
     }
     else if (input.selection === "entries") {
         const first = lowerer.declareHiddenLocal("%entryKey", key.type);
         const keyValue = varRef(first.id, key.type, loc);
-        const pair = { kind: "recordLit", fields: [
-                { name: "0", value: keyValue }, { name: "1", value: collection.kind === "set" ? keyValue : value },
-            ], type: input.element, loc };
+        const pair = {
+            kind: "recordLit",
+            fields: [
+                { name: "0", value: keyValue },
+                { name: "1", value: collection.kind === "set" ? keyValue : value },
+            ],
+            type: input.element,
+            loc,
+        };
         visit = [{ kind: "varDecl", localId: first.id, init: key, loc }, ...append(pair)];
     }
     else
         visit = append(input.selection === "keys" ? key : value);
     locals.push({ id: "i.0", name: "i", type: F64, mutable: true });
-    return [{ kind: "exprStmt", expr: iter("iterEnter", VOID), loc }, { kind: "tryCatch", catchLocalId: null, catchBody: null,
-            tryBody: [countedFor(loc, iter("iterCount", F64), () => [{ kind: "if", cond: iter("iterLive", BOOL), then: visit, else_: null, loc }])],
-            finallyBody: [{ kind: "exprStmt", expr: iter("iterExit", VOID), loc }], loc }];
+    return [
+        { kind: "exprStmt", expr: iter("iterEnter", VOID), loc },
+        {
+            kind: "tryCatch",
+            catchLocalId: null,
+            catchBody: null,
+            tryBody: [
+                countedFor(loc, iter("iterCount", F64), () => [
+                    { kind: "if", cond: iter("iterLive", BOOL), then: visit, else_: null, loc },
+                ]),
+            ],
+            finallyBody: [{ kind: "exprStmt", expr: iter("iterExit", VOID), loc }],
+            loc,
+        },
+    ];
 }
 function cursorConsumption(lowerer, source, element, append, requireIterable, loc) {
     const iterator = lowerer.declareHiddenLocal("%iterator", DYN);
     const next = lowerer.declareHiddenLocal("%next", DYN);
-    const step = lowerer.declareHiddenLocal("%step", DYN);
+    const fast = lowerer.declareHiddenLocal("%nativeIterator", BOOL);
     const raw = lowerer.declareHiddenLocal("%iteratorValue", DYN);
     const done = lowerer.declareHiddenLocal("%done", BOOL);
     done.mutable = true;
-    const get = (value, key) => ({ kind: "dynKeyGet", value, key: strLit(key, loc), type: DYN, loc });
+    const get = (value, key) => ({
+        kind: "dynKeyGet",
+        value,
+        key: strLit(key, loc),
+        type: DYN,
+        loc,
+    });
     const cursor = varRef(iterator.id, DYN, loc);
-    const value = element.kind === "dyn" ? varRef(raw.id, DYN, loc)
-        : { kind: "dynCheck", value: varRef(raw.id, DYN, loc), type: element, preserveRefs: true, loc };
+    const value = element.kind === "dyn"
+        ? varRef(raw.id, DYN, loc)
+        : {
+            kind: "dynCheck",
+            value: varRef(raw.id, DYN, loc),
+            type: element,
+            preserveRefs: true,
+            loc,
+        };
     let body = append(value);
     {
         const error = lowerer.declareHiddenLocal("%iterationError", CAUGHT);
         const close = lowerer.declareHiddenLocal("%return", DYN);
-        body = [{ kind: "tryCatch", tryBody: body, catchLocalId: error.id, finallyBody: null, catchBody: [
-                    { kind: "tryCatch", catchLocalId: null, catchBody: [], finallyBody: null, tryBody: [
+        body = [
+            {
+                kind: "tryCatch",
+                tryBody: body,
+                catchLocalId: error.id,
+                finallyBody: null,
+                catchBody: [
+                    {
+                        kind: "tryCatch",
+                        catchLocalId: null,
+                        catchBody: [],
+                        finallyBody: null,
+                        tryBody: [
                             { kind: "varDecl", localId: close.id, init: get(cursor, "return"), loc },
-                            { kind: "if", cond: { kind: "dynTest", test: "function", value: varRef(close.id, DYN, loc), type: BOOL, loc }, then: [
-                                    { kind: "exprStmt", expr: { kind: "dynCall", callee: varRef(close.id, DYN, loc), receiver: cursor, calleeName: "iterator.return", args: [], type: DYN, loc }, loc },
-                                ], else_: null, loc },
-                        ], loc },
+                            {
+                                kind: "if",
+                                cond: {
+                                    kind: "dynTest",
+                                    test: "function",
+                                    value: varRef(close.id, DYN, loc),
+                                    type: BOOL,
+                                    loc,
+                                },
+                                then: [
+                                    {
+                                        kind: "exprStmt",
+                                        expr: {
+                                            kind: "dynCall",
+                                            callee: varRef(close.id, DYN, loc),
+                                            receiver: cursor,
+                                            calleeName: "iterator.return",
+                                            args: [],
+                                            type: DYN,
+                                            loc,
+                                        },
+                                        loc,
+                                    },
+                                ],
+                                else_: null,
+                                loc,
+                            },
+                        ],
+                        loc,
+                    },
                     { kind: "rethrow", localId: error.id, loc },
-                ], loc }];
+                ],
+                loc,
+            },
+        ];
     }
     return [
-        { kind: "varDecl", localId: iterator.id, init: { kind: "libCall", fn: "dyn.iteratorResult", args: [{ kind: "libCall",
-                        fn: requireIterable ? "dyn.iterator" : "dyn.arrayFromIterator", args: requireIterable ? [source, strLit("Value is not iterable", loc)] : [source], type: DYN, loc }], type: DYN, loc }, loc },
+        {
+            kind: "varDecl",
+            localId: iterator.id,
+            init: {
+                kind: "libCall",
+                fn: "dyn.iteratorResult",
+                args: [
+                    {
+                        kind: "libCall",
+                        fn: requireIterable ? "dyn.iterator" : "dyn.arrayFromIterator",
+                        args: requireIterable ? [source, strLit("Value is not iterable", loc)] : [source],
+                        type: DYN,
+                        loc,
+                    },
+                ],
+                type: DYN,
+                loc,
+            },
+            loc,
+        },
         { kind: "varDecl", localId: next.id, init: get(cursor, "next"), loc },
+        {
+            kind: "varDecl",
+            localId: fast.id,
+            init: iteratorCanStep(cursor, varRef(next.id, DYN, loc), loc),
+            loc,
+        },
         { kind: "varDecl", localId: done.id, init: boolLit(false, loc), loc },
-        { kind: "while", cond: { kind: "unary", op: "!", operand: varRef(done.id, BOOL, loc), type: BOOL, loc }, body: [
-                { kind: "varDecl", localId: step.id, init: { kind: "libCall", fn: "dyn.iteratorResult", args: [{ kind: "dynCall", callee: varRef(next.id, DYN, loc), receiver: cursor, calleeName: "iterator.next", args: [], type: DYN, loc }], type: DYN, loc }, loc },
-                { kind: "assign", localId: done.id, value: { kind: "dynTest", test: "truthy", value: get(varRef(step.id, DYN, loc), "done"), type: BOOL, loc }, loc },
-                { kind: "if", cond: { kind: "unary", op: "!", operand: varRef(done.id, BOOL, loc), type: BOOL, loc }, then: [
-                        { kind: "varDecl", localId: raw.id, init: get(varRef(step.id, DYN, loc), "value"), loc }, ...body,
-                    ], else_: null, loc },
-            ], loc },
+        {
+            kind: "while",
+            cond: { kind: "unary", op: "!", operand: varRef(done.id, BOOL, loc), type: BOOL, loc },
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: raw.id,
+                    init: iteratorValue(lowerer, cursor, varRef(next.id, DYN, loc), varRef(fast.id, BOOL, loc), done, loc, "iterator.next"),
+                    loc,
+                },
+                {
+                    kind: "if",
+                    cond: { kind: "unary", op: "!", operand: varRef(done.id, BOOL, loc), type: BOOL, loc },
+                    then: [...body],
+                    else_: null,
+                    loc,
+                },
+            ],
+            loc,
+        },
     ];
 }
 //# sourceMappingURL=collection-ingestion.js.map